Testdriven utveckling

Introduktion till testning i Java

Maria Milusheva

Senior Software Engineer

Test-Driven Development

Hittills har vi bara skrivit tester efter att ha skrivit produktionskod.

Test-Driven Development (TDD) är en designteknik där tester styr designen
TDD innebär att skriva tester innan någon produktionskod skrivs
Varför använda TDD?

Fördelar med TDD

TDD hjälper dig att bättre uppfylla projektets krav
Omedelbar verifiering – koden har alltid tester
Testbaserad kodning ger renare och bättre strukturerad kod

TDD:s lagar

1. Du måste skriva ett misslyckande test innan du skriver någon produktionskod

2. Du måste skriva kortast möjliga test

3. Du får inte skriva mer produktionskod än vad som krävs för att testet ska passera

Att tillämpa dessa i sekvens = en TDD-cykel

Utvecklingen sker genom upprepade TDD-cykler

¹ https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html

Testa palindromer

Anta att vi vill skriva en metod som kontrollerar om ett heltal är ett palindrom
Exempel på palindromiska heltal: 12321, 0, 3333

Skriv ett misslyckande test innan du skriver någon kod

@Test
public void isPalindrome_nonPalindromicInt_returnsFalse() {
    int number = 1234;

    assertFalse(isPalindrome(number)); // isPalindrome() is not yet written
}

Ett test är som en påminnelse till sitt framtida jag om projektets krav.

Skriv minimal kod för att testet ska passera

public boolean isPalindrome(int num) {
    return false; // Write minimal code that fulfills the requirements of the test.
}

Testet passerar nu. Vi kan gå vidare till nästa TDD-cykel.

Skriv ett nytt test

Nytt test – nytt krav för funktionen:

@Test
public void isPalindrome_PalindromicInt_ReturnsTrue() {
    int number = 1234321; // Now write a more complex test case.

    assertTrue(isPalindrome(number)); // At this point isPalindrome() will fail.
}

Implementera metoden

public boolean isPalindrome(int num) {
    int inverted = 0;
    while (num != 0) {
        // At every iteration take the last digit of the number using % 10
        // and add it to inverted * 10.
        inverted = inverted * 10 + num % 10;
        // Now that we have processed the last digit, discard it using / 10.
        num = num / 10;
    }
    return inverted;
}

Buggfixning med TDD

TDD är utmärkt för att åtgärda buggar!

Metoden vi just skrev returnerar true för number = -121. Det är fel!

Vi skriver ett enhetstest för att illustrera buggen:

@Test
public void isPalindrome_NegativeNumber_ReturnsFalse() {
    int number = -121; // Not a palindrome as -121 is not the same as 121-.

    assertFalse(isPalindrome(number));
}

Buggfixning med TDD

public boolean isPalindrome(int num) {
    if (num < 0) { 
        return false; // We add a clause to return false for negative values.
    }
    int inverted = 0;
    while (num != 0) {
        inverted = inverted * 10 + num % 10;
        num = num / 10;
    }
    return inverted;
}

Nu kör vi en övning!

Introduktion till testning i Java