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!