Skriva tester först
Öva på att skriva underkända tester som definierar det önskade beteendet innan ni implementerar produktionskod.
Skriva tester först är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 2 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.
TDD:s fas Red
Välkommen till kärnan i testdriven utveckling (TDD)! I den här lektionen går vi igenom det viktiga första steget: att först skriva ett test som misslyckas.
Det kallas ofta fasen Red i TDD-cykeln, eftersom Ni förväntar Er att se en röd stapel som visar ett misslyckande när Ni kör testerna.
Varför testa först?
Det kan kännas ologiskt att skriva ett test för kod som ännu inte finns eller inte är färdigimplementerad. Men den här metoden har stora fördelar:
- Tydlighet: Den tvingar Er att tänka på vad koden ska *göra* innan Ni funderar på *hur* den ska göra det.
- Bevis på misslyckande: Den visar att testet fungerar korrekt genom att bevisa att det kan misslyckas. Om det lyckas utan någon kod kan testet vara felaktigt!
- Fokus: Den ger Er ett tydligt, omedelbart mål: få just det här testet att lyckas.
Tester som specifikationer
Betrakta det misslyckade testet som en exakt specifikation eller ett minikrav. Det beskriver ett specifikt beteende som den framtida koden måste ha.
- Det definierar indata.
- Det definierar det förväntade resultatet eller utfallet.
- Det är konkret och körbart.
Det hjälper till att förebygga missförstånd och säkerställer att koden levererar exakt det som behövs i just det scenariot.
Scenario: Enkel kalkylator
Låt oss öva genom att bygga en enkel klass: Calculator. Som vår första funktion vill vi att den ska kunna addera två tal.
Målet är att skriva ett test för en metod, add, som misslyckas innan vi ens har skrivit den korrekta implementationen av add.
Utforma testet som misslyckas
Innan vi skriver kod kan vi tänka igenom följande:
- Vilken indata? Vi adderar
2och3. - Vilket resultat? Vi förväntar oss resultatet
5. - Vilken metod? En metod med namnet
addpå ettCalculator-objekt.
Vi skriver ett test som anropar calculator.add(2, 3) och kontrollerar att resultatet är 5.
Kodexempel: Testet som misslyckas
Här är ett simulerat exempel på att skriva ett test först. Observera att Calculator:s metod add avsiktligt är felaktig (den returnerar 0). Därför misslyckas vårt test, vilket demonstrerar fasen Red.
Kör koden för att se det simulerade misslyckandet!
public class Main {
public static void main(String[] args) {
System.out.println("Running a simulated test...");
Calculator calculator = new Calculator();
// Our test scenario: 2 + 3 should be 5
int expected = 5;
int actual = calculator.add(2, 3);
if (expected == actual) {
System.out.println("Test PASSED: 2 + 3 = " + actual);
} else {
System.out.println("Test FAILED: Expected " + expected + " but got " + actual);
System.out.println("This is our 'Red' phase!");
}
}
}
// The production code (intentionally incorrect for 'Red' phase)
class Calculator {
public int add(int a, int b) {
return 0; // Wrong implementation to make the test fail
}
}Analysera Red
När Ni körde den föregående koden såg Ni meddelandet ”Test FAILED”. Det var precis vad vi ville!
- Förväntat:
5 - Faktiskt:
0
Det här misslyckandet bekräftar två saker: testet är korrekt skrivet, och produktionskoden (metoden add) uppfyller ännu inte det angivna beteendet.
Tänk enligt principen ”minsta möjliga kod”
När Ni har ett test som misslyckas är nästa steg i TDD (fasen Green) att skriva den *enklaste möjliga koden* för att få testet att lyckas.
- Överdesigna inte.
- Lägg inte till extra funktioner.
- Fokusera bara på att uppfylla det aktuella testet som misslyckas.
Det håller koden ren och fokuserad samtidigt som funktionaliteten byggs ut stegvis.
Fördelar med att testa först
Att använda fasen Red i TDD leder till:
- Bättre design: Tester leder Er mot mer modulär och testbar kod.
- Större trygghet: Varje test som lyckas ger Er större tillförsikt om kodens korrekthet.
- Färre buggar: Problem upptäcks tidigt, innan de blir komplexa.
- Levande dokumentation: Era tester fungerar som uppdaterade exempel på hur koden ska användas.
Snabbkontroll av TDD:s Red
Låt oss testa Er förståelse av fasen Red i testdriven utveckling.
Sammanfattning: Fasen Red
Ni har utforskat det viktiga första steget i TDD: att skriva ett test som misslyckas.
- Fasen Red innebär att skriva ett test som misslyckas.
- Testet fungerar som en tydlig specifikation för ny funktionalitet.
- Att se testet misslyckas bekräftar att det är giltigt och att koden ännu inte är korrekt.
- Den här metodiska metoden leder till tydligare krav och mer robust kod.
Härnäst lär vi oss hur vi får det misslyckade testet att lyckas – fasen Green!
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 ”Skriva tester först” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Skriva tester först”, 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 ”Skriva tester först”?
Öva på att skriva underkända tester som definierar det önskade beteendet innan ni implementerar produktionskod. 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 2 av 4.
Hur lång tid tar lektionen ”Skriva tester först”?
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
- Introduktion till TDD-cykeln
- Skriva tester först
- Refaktorering för testbarhet
- TDD:s tre lagar