Lista de conteúdos
Article image
Rafael Lima
Rafael Lima27/01/2024 19:37
Compartilhe

Um pouco sobre Testes

    Hoje em dia, a ausência de rotinas de teste em um software pode ser considerada um problema significativo, como bem destacou Michael Feathers: "Se um código não é acompanhado de testes, ele pode ser considerado de baixa qualidade ou até mesmo um código legado."


    Neste artigo, vou abordar especificamente os testes de unidades, um princípio crucial para o desenvolvimento sustentável de software. Continue lendo se estiver curioso para saber mais sobre essa prática essencial.


    Antigamente, antes da adoção das metodologias ágeis (para mais informações, consulte meu artigo anterior [link]), no fluxo de desenvolvimento em cascata, uma equipe de teste era responsável por conduzir testes de forma manual. Hoje, no entanto, contamos com testes automatizados, simplificando a vida dos profissionais envolvidos no desenvolvimento de sistemas digitais.


    Uma maneira interessante de classificar os testes automatizados é através da Pirâmide de Testes, originalmente proposta por Mike Cohn [link]. A pirâmide categoriza os testes de acordo com sua granularidade.

    image

    Particularmente, os testes podem ser divididos em três grupos: testes de unidade, testes de integração ou testes de serviço, e testes de sistema ou testes de interface com o usuário.

    Particularmente os testes são divididos em três grupos(testes de unidade, testes de integração ou testes de serviço, testes de sistema ou testes de interface com o usuário)

    Testes de Unidade: Verificam automaticamente pequenas partes de um código, normalmente uma classe única. A maioria dos testes se enquadra nessa categoria, sendo mais simples, fáceis de implementar e de execução rápida.

    image

    Testes de Integração ou Testes de Serviço: Verificam uma funcionalidade ou transação completa de um sistema, envolvendo diversas classes e pacotes distintos, podendo até mesmo testar componentes externos, como um banco de dados. Esses testes demandam mais esforço para implementação e têm uma execução mais lenta.

    image

    Testes de Sistema ou Testes de Interface com o Usuário: Simulam de forma fiel uma sessão de uso do sistema por um usuário real. Por serem end-to-end, esses testes são mais caros, mais lentos e menos numerosos. Além disso, os testes de interface tendem a ser mais frágeis, significando que pequenas alterações nos componentes da interface podem exigir modificações nos testes.

    Testes de Unidade

    Os testes de unidade são testes automatizados de pequena unidade de código, normalmente classes, quando o sistema é desenvolvido com paradigma OO. Normalmente as classes são testadas de forma isolada do restante do sistema.

    Resumindo, teste de unidade é quando testamos um métodos, passando parâmetros diferentes e verificando seus retornos, isso de forma automatizada.

    Princípios

    Vamos agora discutir os princípios para implementar bons testes de unidade.

    Os testes de unidade devem satisfazer às seguintes propriedades, cujas iniciais formam a palavra FIRST em inglês:

    • Rápido (Fast): Os desenvolvedores devem executar testes de unidade frequentemente para obter feedback rápido sobre bugs e regressões no código. Portanto, é crucial que esses testes sejam rápidos, executando em questão de milissegundos.
    • Independentes: A ordem de execução dos testes de unidade não é importante. A execução de T1 seguida de T2 deve ter o mesmo resultado da execução de T2 e depois T1. Os testes também podem ser executados de forma concorrente sem afetar os resultados.
    • Determinístico (Repeatable): Os testes de unidade devem sempre produzir o mesmo resultado. Se um teste T é chamado n vezes, o resultado deve ser o mesmo em todas as execuções - ou passa em todas as execuções ou falha em todas.
    • Auto-verificáveis (Self-checking): O resultado de um teste de unidade deve ser facilmente verificável. Os desenvolvedores não devem ter que analisar manualmente arquivos de saída ou fornecer dados manualmente para interpretar os resultados dos testes.
    • Escrito o Quanto Antes (Timely): Idealmente, os testes de unidade devem ser escritos antes mesmo do código que estão testando. O desenvolvimento orientado a testes promove essa prática.

    Para evitar que este artigo fique muito extenso, vou publicar um próximo artigo durante a semana, onde implemento uma classe simples com TypeScript e aplico os conceitos de testes de unidade. Fique ligado!

    Compartilhe
    Comentários (2)
    Rafael Lima
    Rafael Lima - 27/01/2024 21:36

    Sim Leandresson, testes hoje em dia é crucial para termos um bom fluxo de trabalho e principalmente diminuir ao máximo que bugs sejam encontrados em produção.


    Durante a semana vou dedicar um tempo para implementar na prática uma suíte de teste e compartilhar aqui com a comunidade.


    Vlw pelo feedback, tmj.



    Leandresson Fulco
    Leandresson Fulco - 27/01/2024 20:46

    Fala Rafael! Show de bola sua publicação sobre a importância dos testes de unidade no desenvolvimento. Concordo plenamente com a abordagem FIRST para garantir a qualidade e sustentabilidade do código.

    A Pirâmide de Testes proposta por Mike Cohn é uma excelente referência para entender a distribuição adequada dos testes automatizados. Além disso, suas explicações sobre os três grupos de testes (unidade, integração ou serviço, e sistema ou interface com o usuário) são claras e esclarecedoras.

    Em relação aos princípios FIRST, destaco a importância da rapidez na execução dos testes de unidade. Isso proporciona um ciclo de feedback ágil, permitindo aos desenvolvedores identificar e corrigir bugs mais rapidamente. A independência e determinismo dos testes também são fundamentais para garantir a consistência dos resultados, facilitando a manutenção do código ao longo do tempo.

    Quanto ao desenvolvimento orientado a testes, concordo plenamente com a abordagem de escrever os testes antes do código. Essa prática não apenas ajuda a validar a corretude do código desde o início, mas também serve como documentação viva do comportamento esperado.

    Um exemplo prático e simples em Java (que é minha habilidade) para testes de unidade seria algo do tipo:


    import org.junit.Test;
import static org.junit.Assert.*;


public class MinhaClasseTest {


  @Test
  public void testMetodoExemplo() {
      // Arrange (para preparação)
      MinhaClasse minhaInstancia = new MinhaClasse();


      // Act (para ação)
      int resultado = minhaInstancia.metodoExemplo(3, 4);


      // Assert (para verificação)
      assertEquals(7, resultado);
  }
}

    É um exemplo simples, mas ilustra de forma clara o processo de teste de unidade usando JUnit.

    Leia a seguir
    Claudio Mendonça
    Explorando o Aplicativo ScreenToGif: Uma Ferramenta Versátil para Captura de TelaClaudio Mendonça - 07 de Setembro
    #GitHub#DevOps
    Max Silva
    Fortalecendo Fundamentos com Lógica de ProgramaçãoMax Silva - 07 de Setembro
    #Lógica de Programação
    Luiz Café
    Guia das 7 Linguagens que Todo Aspirante a Backend Deve ConhecerLuiz Café - 07 de Setembro
    #Python#Java#JavaScript