Desenvolvimento orientado por testes

Introdução a Testes em Java

Maria Milusheva

Senior Software Engineer

Test-Driven Development

Até aqui, só escrevemos testes depois do código de produção.

Test-Driven Development (TDD) é uma técnica em que os testes guiam o design
No TDD, você escreve os testes antes de qualquer código de produção
Por que usar TDD?

Benefícios do TDD

Desenvolver com TDD ajuda a cumprir melhor os requisitos do projeto
Verificação imediata — todo código já tem testes
Codificar a partir dos testes gera código mais limpo e bem estruturado

As Leis do TDD

1. Escreva um teste que falhe antes de qualquer código de produção

2. Escreva o menor teste possível

3. Não escreva mais código de produção do que o suficiente para passar no teste

Aplicar isso em sequência = um ciclo de TDD

O desenvolvimento acontece por ciclos repetidos de TDD

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

Testando palíndromos

Suponha que queremos escrever um método que verifica se um inteiro é palíndromo
Exemplos de inteiros palíndromos: 12321, 0, 3333

Escreva um teste que falhe antes de qualquer código

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

    assertFalse(isPalindrome(number)); // isPalindrome() ainda não foi escrito
}

Um teste é como um recado para o nosso "eu do futuro", lembrando os requisitos do projeto.

Escreva o mínimo para o teste passar

public boolean isPalindrome(int num) {
    return false; // Escreva o mínimo para cumprir o requisito do teste.
}

O teste agora passa. Podemos ir para o próximo ciclo de TDD.

Escreva outro teste

Novo teste — novo requisito da funcionalidade:

@Test
public void isPalindrome_PalindromicInt_ReturnsTrue() {
    int number = 1234321; // Agora escreva um caso de teste mais complexo.

    assertTrue(isPalindrome(number)); // Neste ponto, isPalindrome() vai falhar.
}

Implemente o método

public boolean isPalindrome(int num) {
    int inverted = 0;
    while (num != 0) {
        // A cada iteração, pegue o último dígito com % 10
        // e adicione a inverted * 10.
        inverted = inverted * 10 + num % 10;
        // Como processamos o último dígito, descarte-o com / 10.
        num = num / 10;
    }
    return inverted;
}

Correção de bug com TDD

TDD é ótimo para corrigir bugs!

O método que acabamos de escrever retorna true para number = -121. Isso está errado!

Vamos escrever um teste de unidade para ilustrar o bug:

@Test
public void isPalindrome_NegativeNumber_ReturnsFalse() {
    int number = -121; // Não é palíndromo, pois -121 não é igual a 121-.

    assertFalse(isPalindrome(number));
}

Correção de bug com TDD

public boolean isPalindrome(int num) {
    if (num < 0) { 
        return false; // Adicionamos uma cláusula para valores negativos.
    }
    int inverted = 0;
    while (num != 0) {
        inverted = inverted * 10 + num % 10;
        num = num / 10;
    }
    return inverted;
}

Vamos praticar!

Introdução a Testes em Java