Criar JUnit Conjunto de testes com exemplo: @RunWith @SuiteClasses

In JUnitUm conjunto de testes nos permite agregar todos os resultados. casos de teste de várias classes em um só lugar e executá-las juntas.

Para executar o conjunto de testes, você precisa anotar uma classe usando as anotações mencionadas abaixo:

1. @RunWith(Suite.class)
2. @SuiteClasses(test1.class, test2.class…) ou @Suite.SuiteClasses({test1.class, test2.class…})

Com as anotações acima, todas as classes de teste no conjunto começarão a ser executadas uma a uma. A classe do conjunto em si permanece vazia: ela serve apenas como um repositório para as anotações, e o executor lê essas anotações para decidir o que executar.

Etapas para criar conjunto de testes e executor de testes

Os quatro passos abaixo constroem o conjunto de testes mais simples que realmente funciona: duas classes de teste comuns, uma classe de conjunto de testes que as nomeia e um executor que inicia o conjunto de testes a partir do método principal.

Passo 1) Crie uma classe de teste simples (por exemplo, `MyFirstClassTest`) e adicione um método anotado com @Teste.

A primeira classe contém um único método de teste vazio, o que é suficiente para provar que o conjunto de testes a detecta:

Passo 2) Crie outra classe de teste para adicionar (por exemplo, MySecondClassTest) e crie um método anotado com @Test.

A segunda classe segue exatamente o mesmo formato, portanto o conjunto possui duas classes separadas para agregar:

Passo 3) Para criar um conjunto de testes (testSuite), primeiro você precisa anotar a classe com @RunWith(Suite.class) e @SuiteClasses(class1.class, class2.class…).

Observe que a classe de suíte TestSuiteExample não declara nenhum método de teste próprio — as duas anotações contêm todas as informações:

Passo 4) Crie uma classe Test Runner para executar nosso conjunto de testes conforme mostrado abaixo:

O corredor é um plano Java classe com um método principal que passa a classe suíte para JUnitNúcleo:

Code Explicação:

• Code Linha 8: Declarando o método principal da classe Test que executará nosso JUnit teste.
• Code Linha 9: Executando casos de teste usando JUnitCore.runClasses, que recebe o nome da classe de teste como parâmetro (no exemplo acima, você está usando TestSuiteExample.class, conforme mostrado na etapa 3).
• Code Linha 11: Processando o resultado usando um laço `for` e imprimindo o resultado com falha.
• Code Linha 13: Imprimindo o resultado bem-sucedido.

Saída: Aqui está o resultado que mostra um teste bem-sucedido, sem falhas. trace conforme indicado abaixo:

A barra verde confirma a finalidade de um conjunto de classes: uma única execução, uma única visualização de resultados e ambas as classes relatadas abaixo do nó do conjunto, em vez de em duas execuções separadas.

JUnit Exemplo de conjunto de testes

Considere um exemplo mais complexo, no qual as classes dentro do conjunto de aplicativos realmente afirmar algo em vez de manter um método vazio.

JunitTest.java

JunitTest.java é uma classe simples anotada com o @Correr com e @Suíte anotações. Você pode listar qualquer número de classes no conjunto como parâmetros, conforme mostrado abaixo:

package guru99.junit;		
import org.junit.runner.RunWith;		
import org.junit.runners.Suite;		

@RunWith(Suite.class)				
@Suite.SuiteClasses({				
  SuiteTest1.class,
  SuiteTest2.class,  			
})		

public class JunitTest {				
			// This class remains empty, it is used only as a holder for the above annotations		
}

SuiteTest1.java

SuiteTest1.java é uma classe de teste que possui métodos de teste que imprimem uma mensagem, conforme mostrado abaixo. Você usará esta classe como um membro do conjunto de testes na classe mencionada acima. Ela depende de uma classe auxiliar chamada JUnitA mensagem, que é definida em outra parte do mesmo pacote e não será reproduzida aqui.

package guru99.junit;		

import static org.junit.Assert.assertEquals;				

import org.junit.Test;		

public class SuiteTest1 {				

    public String message = "Saurabh";							

    JUnitMessage junitMessage = new JUnitMessage(message);							

    @Test(expected = ArithmeticException.class)					
    public void testJUnitMessage() {					

        System.out.println("Junit Message is printing ");					
        junitMessage.printMessage();			

    }		

    @Test		
    public void testJUnitHiMessage() {					
        message = "Hi!" + message;							
        System.out.println("Junit Hi Message is printing ");					
        assertEquals(message, junitMessage.printHiMessage());					
        System.out.println("Suite Test 2 is successful " + message);							
    }		
}		

SuiteTest2.java

SuiteTest2.java é outra classe de teste, semelhante a SuiteTest1.java, que possui um método de teste para imprimir uma mensagem conforme mostrado abaixo. Você usará esta classe como membro de um conjunto de testes em JunitTest.java.

package guru99.junit;		

import org.junit.Assert;		
import org.junit.Test;		

public class SuiteTest2 {				
   	

    @Test		
    public void createAndSetName() {					
        		

        String expected = "Y";					
        String actual = "Y";					

        Assert.assertEquals(expected, actual);					
        System.out.println("Suite Test 1 is successful " + actual);							
    }		

}		

saída

Depois de executar Teste Junit.java, que contém um conjunto de comandos. SuiteTest1.java e SuiteTest2.javaVocê obterá a saída abaixo. O console imprime as mensagens produzidas por ambas as classes:

O JUnit A visualização registra a mesma execução que três métodos de teste aprovados, agrupados na classe da suíte:

Observação: Neste exemplo, os rótulos do console estão cruzados — a string impressa por SuiteTest1 lê “Suite Test 2” e a impressa por SuiteTest2 lê “Suite Test 1”. As listagens originais são reproduzidas sem alterações, portanto, os rótulos permanecem como o autor os escreveu; leia o nome da classe em JUnit Ao comparar a saída com a fonte, visualize o conteúdo em vez da etiqueta impressa.

Como criar um conjunto de testes em JUnit 5

JUnit A versão 5 remove completamente os executores, portanto, `@RunWith(Suite.class)` não existe nos pacotes `org.junit.jupiter`. Os conjuntos de execuções foram movidos para o JUnit Plataforma, que os envia em um artefato separado chamado junit-platform-suite-engineAdicione essa dependência e, em seguida, anote uma classe com @Suite e uma das anotações de seletor.

import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;
import org.junit.platform.suite.api.SuiteDisplayName;

@Suite
@SuiteDisplayName("Guru99 suite")
@SelectClasses({ SuiteTest1.class, SuiteTest2.class })
public class JunitTest {
    // Empty holder, exactly as in JUnit 4
}

As anotações de seletor substituem a lista única @SuiteClasses por uma pequena família de opções:

Duas outras diferenças são importantes na prática. A JUnit A classe `suite` pode declarar os métodos `@BeforeSuite` e `@AfterSuite`, que são executados uma vez em toda a suíte. JUnit O exemplo 4 acima ainda é executado no JUnit A plataforma utiliza o motor gráfico antigo, portanto o código original desta página não precisa ser reescrito para continuar funcionando.

Vantagens e Limitações de JUnit Suites de teste

Uma suíte é um grupoping mecanismo, não um estrutura de teste é própria e isso molda tanto o que ela faz bem quanto onde ela deixa de ser útil.

Vantagens

• Um lançamento executa aulas relacionadas em conjunto, como um conjunto de fumaça ou um regressão A configuração é iniciada com um único comando.
• A visualização de resultados agrupa todas as classes em um único nó de suíte, o que facilita a identificação de falhas comuns.
• A lista de membros reside no código, portanto, é revisada e versionada como qualquer outro arquivo fonte.
• A mesma classe de suíte pode ser executada a partir de uma IDE ou de um executor como... JUnitNúcleo, ou de uma ferramenta de compilação.

Limitações

• @SuiteClasses é uma lista codificada, portanto, uma nova classe de teste é silenciosamente omitida até que alguém edite o conjunto de testes.
• A plataforma não garante a ordem das aulas além da listada em que elas são apresentadas.
• Nada é compartilhado entre as classes membros, portanto, uma suíte não substitui uma acomodação fixa ou uma classe base.
• As ferramentas de compilação já descobrem as classes de teste por meio de convenções de nomenclatura, o que torna um conjunto de testes redundante em muitos projetos.

Erros comuns ao criar um JUnit Suíte de teste

A maioria dos problemas do pacote Suite gera uma mensagem curta e pouco útil. A tabela relaciona as mensagens que você provavelmente encontrará com suas causas e soluções.

Escrevendo a suíte uma vez e continueping O trabalho árduo é justamente a precisão. Se a lista se desviar das classes no disco, o conjunto de testes reporta verde enquanto parte da teste de unidade O comando set nunca é executado, um dos modos de falha mais silenciosos em teste de software.

Perguntas Frequentes