Saiba na Web - Seu ponto de entrada para o mundo virtual

Compartilhe!

 TDD, programando por testes

O que é TDD e quais são as suas vantagens?

TDD (Test-Driven Development, ou Desenvolvimento Orientado a Testes) é uma metodologia de desenvolvimento de software que consiste em escrever testes antes de escrever o código. O objetivo é garantir que o código atenda aos requisitos e funcione corretamente, além de facilitar a manutenção e a refatoração do código.

O processo de TDD segue os seguintes passos:

Escrever um teste para uma nova funcionalidade ou correção de um bug, que deve falhar inicialmente (teste vermelho).
Escrever o código mínimo necessário para fazer o teste passar (teste verde).
Melhorar o código, eliminando duplicações, complexidades desnecessárias e outros problemas de qualidade (refatoração).
Repetir os passos 1 a 3 até que todas as funcionalidades estejam implementadas e testadas.

Algumas das vantagens de usar TDD são:

• Melhorar a qualidade do código, pois os testes garantem que o código faça o que se espera dele, e que não haja regressões quando o código for alterado.
• Melhorar a produtividade do desenvolvedor, pois os testes fornecem um feedback rápido e constante sobre o estado do código, e permitem identificar e corrigir erros mais facilmente.
• Melhorar a confiança do desenvolvedor, pois os testes servem como documentação e especificação do código, e reduzem o medo de mudar o código.
• Melhorar a colaboração entre os desenvolvedores, pois os testes facilitam a integração e a revisão do código, e evitam conflitos e inconsistências.

Como usar TDD com Python e JavaScript?

Para usar TDD com Python e JavaScript, é preciso escolher uma ferramenta de teste adequada para cada linguagem. Existem várias opções disponíveis, mas aqui vamos usar o pytest para Python e o Jest para JavaScript, que são duas ferramentas populares e poderosas para testar código.

Para ilustrar como usar TDD com Python e JavaScript, vamos criar uma função simples que calcula o fatorial de um número inteiro positivo. O fatorial de um número n é o produto de todos os números inteiros positivos menores ou iguais a n. Por exemplo, o fatorial de 5 é 5 x 4 x 3 x 2 x 1 = 120.

TDD com Python e pytest

Para usar TDD com Python e pytest, vamos seguir os seguintes passos:

Criar um arquivo chamado test_factorial.py na pasta tests, que vai conter os testes para a função factorial.
Escrever o primeiro teste para a função factorial, que verifica se ela retorna 1 quando o argumento é 0. Usar a função assert do pytest para verificar se o resultado é igual ao esperado.
Python

# test_factorial.py

def test_factorial_zero():
    # GIVEN a number zero
    number = 0
    # WHEN calculating its factorial
    result = factorial(number)
    # THEN the result should be one
    assert result == 1

Executar o teste com o comando pytest tests/test_factorial.py, que deve falhar, pois a função factorial ainda não foi definida.
Criar um arquivo chamado factorial.py na pasta src, que vai conter a função factorial. Escrever o código mínimo necessário para fazer o teste passar, que é simplesmente retornar 1.
Python

# factorial.py

def factorial(number):
    return 1

Executar o teste novamente, que deve passar, pois a função factorial agora está definida e retorna 1.
Escrever o segundo teste para a função factorial, que verifica se ela retorna o fatorial correto de um número maior que zero. Usar o decorador @pytest.mark.parametrize para testar vários casos de entrada e saída.
Python

# test_factorial.py

import pytest
from src.factorial import factorial

def test_factorial_zero():
    # GIVEN a number zero
    number = 0
    # WHEN calculating its factorial
    result = factorial(number)
    # THEN the result should be one
    assert result == 1

@pytest.mark.parametrize("number, expected",
                         [(1, 1),
                          (2, 2),
                          (3, 6),
                          (4, 24),
                          (5, 120)])
def test_factorial_positive(number, expected):
    # GIVEN a positive number
    # WHEN calculating its factorial
    result = factorial(number)
    # THEN the result should be the expected factorial
    assert result == expected

Executar o teste novamente, que deve falhar, pois a função factorial ainda não está implementada corretamente para números maiores que zero.
Escrever o código necessário para fazer o teste passar, que é usar um loop ou uma recursão para calcular o fatorial.
Python

# factorial.py

def factorial(number):
    if number == 0:
        return 1
    else:
        result = 1
        for i in range(1, number + 1):
            result *= i
        return result

Executar o teste novamente, que deve passar, pois a função factorial agora está implementada corretamente para todos os casos.
Melhorar o código, se necessário, aplicando boas práticas de estilo, documentação, etc.
TDD com JavaScript e Jest
Para usar TDD com JavaScript e Jest, vamos seguir os seguintes passos:

Criar um arquivo chamado factorial.test.js na pasta tests, que vai conter os testes para a função factorial.
Escrever o primeiro teste para a função factorial, que verifica se ela retorna 1 quando o argumento é 0. Usar a função expect do Jest para verificar se o resultado é igual ao esperado.
JavaScript

// factorial.test.js

const factorial = require('../src/factorial');

test('factorial of zero is one', () => {
    // GIVEN a number zero
    const number = 0;
    // WHEN calculating its factorial
    const result = factorial(number);
    // THEN the result should be one
    expect(result).toBe(1);
});

Executar o teste com o comando jest tests/factorial.test.js, que deve falhar, pois a função factorial ainda não foi definida.
Criar um arquivo chamado factorial.js na pasta src, que vai conter a função factorial. Escrever o código mínimo necessário para fazer o teste passar, que é simplesmente retornar 1.
JavaScript

// factorial.js

function factorial(number) {
    return 1;
}

module.exports = factorial;

Executar o teste novamente, que deve passar, pois a função factorial agora está definida e retorna 1.
Escrever o segundo teste para a função factorial, que verifica se ela retorna o fatorial correto de um número maior que zero. Usar a função test.each do Jest para testar vários casos de entrada e saída.
JavaScript

// factorial.test.js

const factorial = require('../src/factorial');

test('factorial of zero is one', () => {
    // GIVEN a number zero
    const number = 0;
    // WHEN calculating its factorial
    const result = factorial(number);
    // THEN the result should be one
    expect(result).toBe(1);
});

test.each([
    [1, 1],
    [2, 2],
    [3, 6],
    [4, 24],
    [5, 120]
])('factorial of %d is %d', (number, expected) => {
    // GIVEN a positive number
    // WHEN calculating its factorial
    const result = factorial(number);
    // THEN the result should be the expected factorial
    expect(result).toBe(expected);
});

Executar o teste novamente, que deve falhar, pois a função factorial ainda não está implementada corretamente para números maiores que zero.
Escrever o código necessário para fazer o teste passar, que é usar um loop ou uma recursão para calcular o fatorial.
JavaScript

// factorial.js

function factorial(number) {
    if (number == 0) {
        return 1;
    } else {
        let result = 1;
        for (let i = 1; i <= number; i++) {
            result *= i;
        }
        return result;
    }
}

module.exports = factorial;

Executar o teste novamente, que deve passar, pois a função factorial agora está implementada corretamente para todos os casos.
Melhorar o código, se necessário, aplicando boas práticas de estilo, documentação, etc.
Espero que este post tenha te ajudado.

 

Fontes:

Testdriven.io
Obeythetestinggoat.com
Ciência moderna.com.br

Compartilhe »