Isenção de responsabilidade

Esta é uma repostagem do meu artigo no Medium.com com a esperança de alcançar mais desenvolvedores de OSS como parte do #Hacktoberfest.

Introdução

Você já teve que lidar com testes paralelizados instáveis ​​​​que passam na maior parte do tempo, mas de repente começam a falhar com erros aleatórios inconsistentes? Você já teve que consertar testes que compartilham os mesmos arquivos de recursos e modificá-los em paralelo para confundir você e os resultados de seus outros testes? Você passou inúmeras noites tentando refatorar esse código para que ele pudesse ser paralelizado adequadamente e ter resultados reproduzíveis e garantidos?

Este é um tópico complexo que nem sempre é fácil de resolver, especialmente em grandes bases de código existentes. No entanto, seguir um conjunto simples de regras pode ajudá-lo a chegar lá e a estrutura carlspring/idempotence visa ajudar com isso.

O que é isolamento de teste?

Para que os testes sejam reproduzíveis o tempo todo, você precisa ter certeza de que seus arquivos de recursos estão contidos e isolados apenas para eles. O que isso significa é que cada teste deve possuir exclusivamente seus recursos de teste e outros testes não devem modificá-los.

O que é idempotência de teste?

Idempotência de teste significa que seus testes sempre retornarão os mesmos resultados. Não importa quantas vezes eles tenham sido executados e não importa quais outros testes estejam sendo executados em paralelo.

Qual é a estrutura carlspring/idempotence para Java

Esta é uma estrutura leve que ajuda a definir e copiar arquivos de recursos de teste de forma isolada para seus testes JUnit5. Os recursos de teste são definidos usando anotações e copiados em seus próprios diretórios para ajudar na implementação da separação e isolamento de recursos de teste.

Como funciona a estrutura Java carlspring/idempotence

Todos os recursos de teste comuns são armazenados no diretório src/test/resources como de costume. Cada método de teste define os recursos necessários usando a anotação @TestResources. A estrutura copia esses recursos para um diretório isolado para cada método de teste. Isso garante que ele tenha acesso exclusivo aos recursos necessários, evitando interferência de outros testes executados em paralelo, incluindo outros métodos de teste na mesma classe de teste.

Para cada ferramenta de construção, há uma dependência separada que contém lógica de transformação relacionada ao caminho para o layout de diretório específico dessa ferramenta. (Como um exemplo muito simplificado, entre outras coisas. O Maven coloca o código construído no destino, enquanto o Gradle usa o build para essa finalidade; os recursos são colocados de forma diferente, etc.). Mais sobre isso será explicado abaixo.

Como escrever testes usando a estrutura Java carlspring/idempotence

Aqui estão as etapas necessárias para começar.

Defina as dependências

Você precisará definir a respectiva dependência para sua ferramenta de construção. Você pode verificar qual é a última versão lançada aqui.

• Para Gradle (usando Groovy DSL):

testImplementation "org.carlspring.testing.idempotence:idempotence-gradle:1.0.0-rc-3"

• Gradle (usando Kotlin DSL):

testImplementation("org.carlspring.testing.idempotence:idempotence-gradle:1.0.0-rc-3")

• Para Maven:

org.carlspring.testing.idempotenceidempotence-maven1.0.0-rc-3test

Adicionar anotações

Sua classe de teste deverá ser anotada com a anotação @ExtendWith(TestResourceExtension.class). Esta anotação é responsável pela cópia real dos recursos.

Você também precisará anotar seus métodos de teste com a anotação @TestResources para especificar os recursos necessários.

Por exemplo:

package com.foo;

import org.carlspring.testing.idempotence.annotation.TestResource;
import org.carlspring.testing.idempotence.annotation.TestResources;
import org.carlspring.testing.idempotence.extension.TestResourceExtension;

@ExtendWith(TestResourceExtension.class)
class MyTest {

    @Test
    @TestResources({ @TestResource(source = "classpath:/foo.txt"),
                     @TestResource(source = "classpath*:/**/bar.txt")} )
    void testFoo()
    {
        // Perform whatever checks you need using these resources
    }

}

Para cada método de teste será criado um diretório usando o seguinte formato:

• Para um projeto Gradle, com um teste chamado MyTest com um método testFoo, eles serão colocados em:

build/test-resources/MyTest-testFoo/nested/dir/foo.txt
build/test-resources/MyTest-testFoo/bar.txt

• Para um projeto Maven, com um teste chamado MyTest com um método testFoo, eles serão colocados em:

target/test-resources/MyTest-testFoo/nested/dir/foo.txt
target/test-resources/MyTest-testFoo/bar.txt

Dessa forma, seus testes terão os recursos necessários copiados em seus próprios diretórios isolados. Neste ponto você pode modificar esses recursos de teste a partir dos métodos de teste aos quais pertencem e seus resultados devem ser idempotentes, desde que dependam apenas de recursos baseados em arquivo e não de outros tipos de recursos compartilhados (banco de dados, serviços de terceiros, etc.).

Onde encontrar a documentação

A documentação do projeto Idempotence pode ser encontrada aqui.

Você pode dar uma olhada na Visão Geral Conceitual para uma explicação mais detalhada de como as coisas funcionam.

Como contribuir

Este é um projeto greenfield com funcionalidade e infraestrutura básicas instaladas, mas ajuda é sempre bem-vinda.

Contribuidores com experiência com JUnit, Springframework e MkDocs podem ajudar a moldar o projeto com ótimas ideias e soluções. Os primeiros usuários que poderiam fornecer feedback também são muito bem-vindos!

Problemas rotulados como hacktoberfest ou procura-se ajuda estão à sua disposição e devem ajudá-lo a começar rapidamente. Você pode encontrá-los aqui.

Conclusão

Uma das coisas mais importantes ao escrever casos de teste são os dados de teste que seus testes usarão e mantê-los corretos entre as execuções. Seguindo um conjunto de regras simples para manter esses dados isolados entre seus testes, você pode obter idempotência e confiabilidade de seus resultados.

O projeto carlspring/idempotence fornece uma estrutura fácil de usar que é adequada tanto para projetos greenfield quanto para legados de refatoração.