A arte de escrever código inútil

No outro dia estava eu a passear pela rua e a ler uns artigos sobre TDD no telemóvel entre outros e deparei-me com o o seguinte pensamento: “É incrível como temos a capacidade de escrever código que provavelmente é inútil”.

Coloquei-me a pensar em experiências passadas, no código que já tinha escrito, nos testes unitários e de integração que fiz e nos livros que já expreitei sobre este assunto. As boas práticas dizem que devemos escrever testes unitários mais testes de integração mais testes disto e mais testes daquilo, etc etc etc … livros falam muito bem sobre estas coisas… muitas teorias… são válidadas atenção, não estou a criticar! Podes e deves continuar a ler.

Agora vamos passar para um exemplo prático e pensar nestes testes que temos que fazer. Imagina que tens um serviço de gestão de produtos, cujas funcionalidade que negócio pede são:

• Adicionar novos produtos;
• Listar todos os produtos;
• Pesquisar produtos através do nome;

Imagina que o teu serviço tem o seguinte método, esquecendo a robustez do mesmo:

public Product AddProduct(Product product)
{
    if(product is null)
        throw new ArgumentNullException(nameof(product));
    
    productsRepository.Add(product);
    return product;
}

Certamente irás fazer uns 2 testes unitários para testar este método:

• Um para verificar se o método retorna excepção, caso não é passado um produto;
• Um para verificar se ao chamares o método AddProduct com um produto válido, é invocado o método Add do productRepository, além de ainda fazeres código para “mockar” o repositório;

Após os testes unitários ainda fazes um teste de integração, usando o TestServer que é qualquer coisa de espectacular (recomendo caso estejas a usar .Net Core), que valida se um produto é adicionado.

Pergunto-me: Qual destes testes te garante mais segurança?

Será que este último teste não me é suficiente para garantir as regras de negócio que nos são requeridas? Ou estarei mais interessada em que aquela excepção seja lançada e aquele método x seja chamado? Fica para pensares.

O que acontece se fores refactorizar o teu código? Aqueles testes unitários vão partir e vais ter que os refactorizar também. Ora, mas não é suposto fazer testes para garantir o funcionamento do negócio do serviço? Refactorizar com segurança sem ter que alterar os meus testes? 😤

Somos de facto grandes artistas! Muitos de nós gostam de seguir tudo o que os grandes livros nos dizem, incluindo eu mas e que tal começar a usar a minha cabeça? O que fará mais sentido para mim? Tudo tem uma razão de ser, na nossa área tudo tem uma lógica.

Deixo para reflectires!

Obrigado!