Menu

Conjunto de testes JUnit e casos de teste de filtragem: JUnit 4 Vs JUnit 5

  • Principal
  • De Outros
  • Conjunto de testes JUnit e casos de teste de filtragem: JUnit 4 Vs JUnit 5

junit test suite filtering test cases

Experimente Nosso Instrumento Para Eliminar Problemas

perguntas e respostas da entrevista qtp com 4 anos de experiência

Este tutorial discutirá o que é um conjunto de testes JUnit, como criar um conjunto de testes e como filtrar casos de teste no JUnit 4 vs JUnit 5:

Aprendemos como pular certos casos de teste durante a execução em nosso tutorial anterior. Também aprendemos sobre as diferentes anotações usadas no JUnit 4 e no JUnit 5 para fazer isso.

Neste tutorial, aprenderemos:

  • O que é um conjunto de testes?
  • Como criamos uma suíte de teste encapsulando vários casos de teste em um grupo e executando a suíte usando a classe JUnitCore?

=> Visite aqui para obter a série exclusiva de tutoriais de treinamento JUnit.

Conjunto de testes JUnit e caso de teste de filtragem

O que você aprenderá:

Conjunto de testes JUnit

JUnit 4: @RunWith, @SuiteClasses Annotations

O tutorial Várias maneiras de executar testes JUnit ilustrou como criar um conjunto de testes em JUnit 4.

As anotações @Correr com e @SuiteClasses nos ajudou a criar um conjunto de testes agrupando várias classes de teste JUnit. Posteriormente, um arquivo runner com a classe JUnitCore.runclasses () invocou a execução do conjunto de testes criado.

Consulte a seção mencionada para todos os detalhes minuciosos sobre o fluxo de trabalho, juntamente com o código real para JUnit 4.

JUnit 5: @RunWith, @SelectClasses, @SelectPackages Annotations

A criação de um conjunto de testes em JUnit 5 é bastante semelhante ao que temos no JUnit 4. Então, onde está a diferença?

# 1) No JUnit 4 , temos Suite.class que é passado como um parâmetro para a anotação @RunWith para apoiar a criação de um conjunto de testes, enquanto JUnit 5 usa a mesma anotação @RunWith, mas com o parâmetro de entrada como JUnitPlatform.class ao invés de Suite.class .

Portanto, a linha de código em JUnit 5 parece @RunWith (JUnitPlatform.class). Esta é a anotação que acompanha seu subprojeto JUnit Platform.

#dois) No JUnit 4 , nós usamos @SuiteClasses para agrupar várias classes JUnit separadas por uma vírgula enquanto em JUnit 5 temos:

  • A anotação @SelectClasses isso é equivalente a @SuiteClasses no JUnit 4 para agrupar várias classes JUnit.
  • @SelectPackages a anotação é usada para agrupar vários testes do (s) pacote (s). Você precisa inserir um valor de array de string que representa o pacote que você deseja incluir.

Assim, em outras palavras,

  1. Se você quiser agrupar casos de teste de um único pacote, o JUnit 5 permite que você faça isso.
  2. Ou no caso de você desejar agrupar casos de teste de vários pacotes, o JUnit 5 oferece suporte para que você faça isso também. Uma nota a lembrar aqui é que os testes em todos os subpacotes do pacote mencionado também são incluídos no conjunto de testes por padrão.

JUnit 5: Cenários / Exemplos Diferentes

Criação de um conjunto de testes agrupando várias classes de teste

O snippet do código é mostrado abaixo:

@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { }

Criando um conjunto de testes para pacote único

O snippet do código é mostrado abaixo:

@RunWith(JUnitPlatform.class) @SelectPackages({“ demo.tests “}) public class JUnit5TestSuite { }

Observação :

  1. Dizer demo.tests o pacote tem um subpacote demo.tests.subtests.
  2. O código @SelectPackages ({“demo.tests“}) irá incluir todos os testes do subpacote, também, no conjunto de testes; por padrão.
  3. Se você tivesse declarado @SelectPackages ({“demo.tests.subtests“}) , os casos de teste no subpacote demo.tests.subtests só será incluído no conjunto de testes, enquanto os testes de seu pacote pai, ou seja, demo.tests não seria incluído.

Criando um conjunto de testes para vários pacotes

O snippet de código para criar um conjunto de testes para pacotes múltiplos separados por uma vírgula no JUnit 5 - terá a seguinte aparência:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests”, “demo1.tests”, “demo2.tests”}) public class JUnit5TestSuite { }

Conjunto de testes de filtragem - JUnit 4 vs JUnit 5

Às vezes, precisamos filtrar os casos de teste e executar um conjunto específico de testes de acordo com nossas necessidades. Por exemplo, pode haver um conjunto de testes identificados para teste de regressão, um conjunto separado para teste de unidade e um conjunto separado de casos de teste para teste de fumaça.

Precisamos excluir ou incluir casos de teste de certos pacotes, classes ou categorias. Filtrar ou marcar os testes de um único pacote é a única opção com JUnit4.

Comparado ao JUnit 4, o JUnit 5 vem com um bom conjunto de recursos para dar suporte a essa necessidade de filtrar seus casos de teste de um único pacote ou vários pacotes e subpacotes de acordo com seus requisitos de mudança.

JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory

Os casos de teste no JUnit 4 podem ser categorizados em diferentes categorias. Essas categorias podem ser excluídas ou incluídas durante a execução de seu conjunto de testes. As anotações @Category, @IncludeCategory e @ExcludeCategory são suportados pelo JUnit 4.12 e superior.

As etapas de alto nível para criar os filtros com base na categoria ou categorias são as seguintes:

# 1) Crie uma interface de marcador que desempenhe um papel na categoria.

#dois) Anote os métodos de teste das classes a serem incluídas nas SuiteClasses com @Categoria e o nome da categoria.

# 3) No arquivo de suíte de teste, use anotação @IncludeCategory com o nome da categoria para incluir os testes pertencentes a uma categoria específica.

# 4) No arquivo de suíte de teste, use anotação @ExcludeCategory com o nome da categoria para excluí-los.

# 5) A anotação @Category pode ser usada no nível de teste ou de classe também. Se a anotação for aplicada no nível de teste, esse teste específico será marcado com a categoria fornecida, enquanto se a anotação for no nível de classe, todos os testes dentro da classe serão marcados com a categoria dada.

Vejamos mais alguns detalhes para entender a implementação prática de categorizar os testes e filtrá-los para execução:

Passo 1:

Começaremos com a criação de um interface do marcador que vai desempenhar o papel de um categoria para métodos de teste. Aqui, criamos uma categoria chamada Teste de unidade . O código é muito simples. Por favor, consulte o código abaixo.

Código para UnitTest.java

package demo.tests; public interface UnitTest {}

Passo 2:

Devemos marcar a categoria no nível de método de teste na aula JUnitTestCase1.java . Para adicionar o caso de teste junitMethod1 () na categoria UnitTest, precisamos anotar o método de teste com @Category (UnitTest.class) .

Isso adiciona o método de teste à categoria UnitTest. Os outros métodos de teste (se houver) não são marcados com a categoria, a menos que os métodos sejam anotados com uma categoria.

Para ter a anotação @Category funcionando em nosso código, precisamos importar o pacote org.junit.experimental.categories.Category

O snippet de código de JUnitTestCase1.java:

@Category(UnitTest.class) @Test public void junitMethod1(){ int Value2=9000; Assert. assertEquals (Value1, Value2); }

Como alternativa, um método de teste também pode pertencer a várias categorias Por exemplo. : @Category (UnitTest.class, SmokeTest.class)

Etapa 3:

Eu iria agora, marcar a categoria no nível da classe na aula JUnitTestCase2.java . A mesma instrução que foi adicionada no nível do método de teste na etapa anterior também será adicionada ao arquivo de classe atual.

Observe que aqui, adicionaremos a instrução no nível da classe. Isso fará com que todos os métodos de teste no arquivo pertençam ao Teste de unidade Categoria.

O snippet de código de JUnitTestCase2.java:

@Category(UnitTest.class) @Test public class JUnitTestCase2 { public String stringValue='JUnit';

Passo 4:

qa entrevista perguntas e respostas para caloiros

Agora que nossos casos de teste necessários foram categorizados na categoria UnitTest, veremos como adicioná-los ao conjunto de testes filtrando-os com base na categoria. Devemos fazer certas alterações de código no JUnitTestSuite.class para demonstrar isso.

  • Categories.class será passado como parâmetro para a anotação @RunWith.
  • @ Suite.SuiteClasses pegará o array de strings das classes de teste.
  • A anotação @ Categories.IncludeCategory precisará UnitTest.class como o parâmetro.
  • Essa declaração nos ajudará a filtrar todo o pacote e executar apenas os casos de teste do pacote que pertence à categoria.
  • Categories.class need package org.junit.experimental.categories.Categories a ser importado.

O snippet de código para JunitTestSuite.java

@RunWith(Categories.class) @Categories.IncludeCategory(UnitTest.class) @Suite.SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class}) public class JUnitTestSuite {

A anotação @ Categories.IncludeCategory também pode ser escrito como @IncludeCategory. Você também pode criar várias interfaces (categorias) e anotar os métodos de classe / teste com várias categorias separadas por uma vírgula. O exemplo a seguir filtrará os testes pertencentes à categoria - Categoria1 e Categoria2.

Exemplo: @IncludeCategory ({Category1.class, Category2.class})

Regras semelhantes vão com @ Categories.ExcludeCategory / @ExcludeCategory para excluir os métodos de teste na categoria ou categorias durante a execução do teste.

JUnit 5 - @IncludeTags, @ExcludeTags, @IncludePackages, @ExcludePackages, @IncludeClassNamePatterns, @ExcludeClassNamePatterns

JUnit 5 vem embalado com várias abordagens para organizar e filtrar os casos de teste.

JUnit 5 - @IncludeTags, @ExcludeTags

# 1) Como o JUnit 4, possui anotações @IncludeCategory e @ExcludeCategory para suportar a filtragem de casos de teste para execução.

#dois) JUnit 5 tem anotações @IncludeTags e @ExcludeTags para atingir o mesmo propósito.

# 3) JUnit 4 se refere aos casos de teste a serem organizados em uma categoria específica, enquanto JUnit 5 se refere à marcação dos casos de teste com uma tag específica para permitir a filtragem dos casos de teste para execução.

As etapas de alto nível para criar os filtros com base nas tags são as seguintes:

  1. Anote os métodos de teste do (s) pacote (s) a serem incluídos no @SelectPackages com @Marcação e o nome da tag definida pelo usuário. Uma classe pode ter tags diferentes para métodos de teste diferentes.
  2. Você também pode anotar @Tag no nível da classe para que todos os testes da classe sejam marcados.
  3. No arquivo de suíte de teste, use anotação @IncludeTags com o nome da tag para incluir os testes pertencentes a uma tag específica.
  4. No arquivo de suíte de teste, use anotação @ExcludeTags com o nome da tag para excluí-los do conjunto de testes.

Vamos agora ter uma ilustração detalhada sobre como implementar de forma prática a filtragem no JUnit 5.

Passo 1 : Estamos marcando um método de teste em JUnit5TestCase1.java para o nome da tag 'Regressão'

O snippet de código de JUnit5TestCase1.java:

@Tag(“Regression”) @Test public void junitMethod1(){

Passo 2 : Estamos marcando um método de teste em JUnit5TestCase2.java para o nome de tag “SmokeTest”.

O snippet de código de JUnit5TestCase2.java:

@Tag(“SmokeTest”) @Test public void junitMethod2(){

Etapa 3: Agora que os métodos de teste foram marcados, iremos atualizar JUnit5TestSuite.java para adicionar filtros apropriados por marcações para os testes. O código a seguir inclui todos os testes marcados como ‘Regressão’ e exclui todos aqueles marcados como ‘SmokeTest’.

O snippet de código de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { }

JUnit 5 - @IncludePackages, @ExcludePackages

Já sabemos disso quando passamos o nome de um pacote no @SelectPackages anotação, os testes nos subpacotes do pacote também são adicionados ao conjunto de testes.

Pode haver certos subpacotes que desejamos incluir em nossa suíte de teste, enquanto alguns outros subpacotes que não queremos ou podem não ser relevantes para serem incluídos em nossa suíte.

Isso é facilitado pelas anotações @IncludePackages e @ExcludePackages no JUnit 5.

Vamos supor que temos um pacote ‘demo.tests’ que tem três subpacotes, ou seja, subpacote1, subpacote2 e subpacote 3 com suas classes de teste em cada um dos pacotes abaixo.

pacote ‘demo.tests’ com três subpacotes

Vamos ver um trecho de código de JUnit5TestSuite.java para visualizar como incluir e excluir um pacote.

Cenário 1: Aplique o filtro para incluir casos de teste apenas do subpacote1.

O código a seguir inclui todos os testes de todas as classes JUnit no pacote demo.tests.subpackage1, no entanto, exclui todos os testes diretamente no pacote demo.test e aqueles no pacote subpackage2 e subpackage3.

O snippet de código de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludePackages(“demo.tests.subpackage1”) public class JUnit5TestSuite { }

Cenário 2: Aplique o filtro para excluir casos de teste apenas do subpacote3 do pacote.

O código a seguir exclui todos os testes das classes JUnit no pacote - demo.tests.subpackage3, no entanto, o conjunto inclui todos os testes diretamente no pacote demo.test e aqueles no pacote subpackage1 e subpackage2.

O snippet de código de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludePackages(“demo.tests.subpackage3”) public class JUnit5TestSuite { }

JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns

Quando você deseja incluir ou excluir certas classes que correspondem a uma expressão regular específica do pacote, as anotações @ IncludeClassNamePatterns e @ ExcludeClassnamePatterns pode ser usado no arquivo de classe do conjunto de testes.

Vamos agora ver a ilustração por meio da atualização do código em JUnit5TestSuite.java

Cenário 1:

O código a seguir inclui classes que terminam com ‘Ctests’ do pacote demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeClassNamePatterns({'^.*CTests?$'})

Cenário 2:

Devemos agora excluir as classes que iniciar com ‘STest’ do pacote demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludeClassNamePatterns({'^STest.*$'})

Cenário # 3:

Várias expressões regulares também podem ser passadas como critérios de filtro. O código a seguir declara duas expressões regulares diferentes separadas por ' OU ”Operador. A barra de fenda | é o operador OR aqui.

melhor software de recuperação de dados para disco rígido externo

O código filtra as classes iniciando com Teste ( Teste.*) ou final com Testes (*. Testes?) e inclui essas classes no conjunto de testes como a anotação @IncludeClassNamePatterns é usada.

Nota: Se o nome de classe totalmente qualificado corresponder a pelo menos um padrão, a classe será buscada de acordo com a anotação @IncludeClassNamePatterns ou @ExcludeClassNamePatterns.

@RunWith (JUnitPlatform.class)

@SelectPackages ({“demo.tests“})

@IncludeClassNamePatterns (. * Tests?) $ ”)

Perguntas frequentes sobre casos de teste de filtragem JUnit

Aqui está uma pergunta que pode estar persistindo em sua mente há algum tempo.

P # 1) Qual é a diferença entre desativar / ignorar um teste e filtrar um teste? Qualquer um dos recursos não pode servir ao mesmo propósito de pular casos de teste durante a execução?

Resposta: A pergunta é realmente genuína e vale a pena respondê-la.

  1. Com o recurso de teste de filtragem, você pode excluir, bem como incluir testes dependendo da categoria marcada. Ao passo que, com a desativação, você pode decidir apenas excluir e não incluir testes para execução.
  2. Filtrar os casos de teste é um tipo de caso de teste que ignora condicionalmente, enquanto que, no caso de testes Ignorados, esses são ignorados sem condições.
  3. Outra diferença significativa entre os dois é que quando você executa os casos de teste com testes anotados com @Ignore ou @Disabled - os testes ignorados são exibidos nos resultados do teste sob o PULADO contar
  4. Quando você executa os testes filtrados, eles não aparecem no resultado do teste.

Conclusão

Neste tutorial, aprendemos como filtrar testes adicionando uma categoria / tag aos testes.

Aprendemos no JUnit 4 que temos @Category, @IncludeCategory e @ExcludeCategory para filtrar os casos de teste, enquanto o JUnit 5 tem @IncludeTags e @ExcludeTags para fazer o mesmo.

Além disso, JUnit 5 tem opções de filtragem adicionais usando anotações @IncludePackages, @ExcludePackages e também anotações para incluir ou excluir classes usando padrões de nome de classe. Quanto mais exploramos; percebemos que ainda há muito mais a explorar.

=> Cuidado com a série de treinamento JUnit simples aqui.

Leitura recomendada

^