Várias maneiras de executar testes JUnit

multiple ways execute junit tests

Este tutorial mostra várias maneiras de executar testes JUnit, como executar como teste JUnit, usar teclas de atalho ou executar teste JUnit na linha de comando, etc:

Vimos como escrever os casos de teste JUnit básicos e ter uma abordagem de fixação de teste como uma das boas práticas de programação para JUnit em nosso tutorial anterior.

Neste tutorial, vamos dar uma olhada nas diferentes maneiras que podemos usar para executar testes para JUnit. Você ficará surpreso ao ver o número de opções disponíveis para executar esses casos de teste.

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

O que você aprenderá:

• Diferentes maneiras de executar testes JUnit
  • # 1) Executar como teste JUnit
  • # 2) Executar o último teste JUnit executado por meio da opção de menu
  • # 3) Executar usando teclas de atalho
  • # 4) Execute apenas um método de teste em uma classe
  • # 5) Executar testes JUnit na linha de comando
  • # 6) Execute o conjunto de testes usando a classe Testrunner
  • # 7) Executar casos de teste JUnit usando Maven
• Conclusão
• Leitura recomendada

Diferentes maneiras de executar testes JUnit

Para executar testes JUnit, existem certas maneiras pelas quais você pode executar um único arquivo de classe com um ou vários métodos de teste por meio das seguintes opções:

1. Opção ‘Executar como teste JUnit’.
2. Execute o último teste JUnit executado por meio da opção de menu.
3. Execute usando as teclas de atalho.
4. Execute apenas um método de teste em uma classe.
5. Execute através da linha de comando.
6. Execute usando o arquivo de classe Testrunner.
7. Execute usando o Maven também.

Observação: A execução do teste JUnit por meio do Maven será contemplada em um tutorial separado para o JUnit Maven.

Reiterando o ponto, neste tutorial, aprenderemos como vários testes podem ser agrupados em um conjunto de testes e como alguém poderia executar o conjunto de maneiras diferentes. Além disso, deve detalhar certas informações adicionais relevantes e relacionadas.

# 1) Executar como teste JUnit

A maneira mais simples de executar os testes JUnit é:

Método 1:

1. Clique com o botão direito no arquivo de classe na visualização de Script
2. Selecione Executar como -> Teste JUnit
3. O arquivo de classe é executado.

Método 2:

1. Da mesma forma, você pode selecionar o arquivo de classe na visualização Package Explorer
2. Clique com o botão direito no arquivo
3. Selecione Executar como -> Teste JUnit
4. O arquivo de classe é executado.

Observação: Desta forma, você pode executar um arquivo de classe por vez.

# 2) Executar o último teste JUnit executado por meio da opção de menu

Você pode executar um arquivo de classe JUnit mantendo um arquivo de classe aberto no editor. Vá para o menu superior do Eclipse => Selecione Executar => Executar . A opção Executar -> Executar basicamente significa executar novamente o último teste executado.

Vamos considerar uma classe JUnit com vários métodos / testes para melhor clareza sobre como Executar-> Executar funciona:

• Cenário 1 : Se você tivesse executado um método único com @Test, então quando você clica Executar-> Executar , o único método executado por último só executaria desta vez e não toda a classe JUnit.
• Cenário 2 :Considerando que você executou o aula inteira anteriormente, Executar-> Executar iria executar novamente o arquivo de classe inteiro.

Agora que sabemos que Executar-> Executar executa o teste que você executou por último, isso nos leva a um pergunta se você pode alterar a preferência da opção Executar-> Executar?

A resposta à pergunta é Sim, a preferência da opção Executar-> Executar pode ser alterada. Há uma certa configuração anexada a Executar-> Executar.

Veja como você pode fazer isso:

para) A configuração de execução do Eclipse basicamente tem como padrão execute o recurso selecionado ou editor ativo se for inicializável .

Então, o que a configuração padrão - ‘Executar o recurso selecionado ou editor ativo se for inicializável’ fazer?

A resposta para isso é que ele não executará o aplicativo que você iniciou por último, em vez disso, seguirá a execução do último aplicativo iniciado por o editor ativo .

b) Então, como você altera a preferência padrão?

A resposta para isso é que você pode alterar a preferência padrão no Eclipse para executar o último aplicativo iniciado independentemente do editor ativo você tem.

Abaixo está como você altera a preferência da opção Executar usando Executar -> Executar:

• Navegar para Windows => Preferências => Executar / Depurar => Iniciando
• ‘Operação de lançamento’ tem um botão de opção padrão - ' Inicie o aplicativo lançado anteriormente ' selecionado na segunda opção ‘ Inicie o recurso selecionado ou editor ativo. Se não for inicializável : ’.
• Pode ser necessário alterar essa preferência para o primeiro botão de opção, ou seja, ' Sempre inicie o aplicativo lançado anteriormente '.

# 3) Executar usando teclas de atalho

Você pode selecionar o arquivo de classe na visualização Script ou na visualização Package Explorer e usar as teclas de atalho abaixo para executar os testes JUnit:

1. Pressione as teclas ALT + SHIFT + X, T para executar o arquivo de classe JUnit.
2. Uma alternativa para isso seria pressionar ALT + R em seguida CTRL + F11 para executar um arquivo de classe JUnit. ALT + R em seguida CTRL + F11 é o atalho para a opção do menu Executar -> Executar

# 4) Execute apenas um método de teste em uma classe

Às vezes, você pode querer executar um único método de teste JUnit.

Nesse caso, há mais de um método dentro do arquivo de classe JUnit:

1. Você pode selecionar ou colocar o cursor no nome do método dentro da visualização do script.
2. Use as teclas de atalho mencionadas acima ou as opções fornecidas acima para executar apenas o método que você acabou de selecionar.

Observação: ALT + SHIFT + X, T pode executar métodos selecionados conforme o esperado. No entanto, se você deseja executar um método específico em uma classe JUnit, deve ser um caso de teste anotado com @Test, caso contrário, ele mostra um erro de inicialização.

Em outras palavras, se você selecionar métodos em @Before ou @After (qualquer anotação diferente de @Test), a execução do método específico apresentará um erro.

# 5) Executar testes JUnit na linha de comando

Como você executa qualquer arquivo de classe Java via linha de comando, você também pode compilar e executar arquivos de classe JUnit por meio da linha de comando.

Cobriremos os subtópicos abaixo aqui para obter uma compreensão de como podemos executar testes JUnit por meio da linha de comando:

1. Como compilar um teste JUnit na linha de comando?
2. Como executar um teste JUnit na linha de comando?
3. Informações adicionais sobre a execução da linha de comando.
   • Como corrigir erro de comando não reconhecido para o comando javac?
   • Vantagens de executar testes usando a linha de comando.

# 5.1) Como compilar um teste JUnit na linha de comando?

A pré-condição para compilar e executar um arquivo de classe JUnit via prompt de comando é:

1. Primeiro, adicione os arquivos jar JUnit relevantes ao classpath.
2. Defina as variáveis ​​de ambiente como foi mencionado no Configuração de JUnit tutorial.
3. Em seguida, compile um arquivo de classe JUnit.
4. A sintaxe para compilar um arquivo de classe JUnit por meio da linha de comando é:

Aqui, javac é o compilador Java que usa a opção -cp.

O comando javac -cp procura os seguintes parâmetros:

1. O arquivo jar JUnit é seguido por um ponto e vírgula.
2. O caminho do diretório no qual o arquivo de origem existe.
3. O nome do arquivo da classe

Na sintaxe fornecida acima, o que o ponto (.) Implica?

Mencionamos um ponto no lugar de todo o caminho do diretório.

O ponto indica que:

1. O caminho de classe já inclui o diretório atual para os arquivos de origem Java.
2. A JVM (Java Virtual Machine) assume automaticamente que o diretório atual é onde os arquivos de origem são colocados.
3. A JVM então procura o nome do arquivo JUnit mencionado lá. O nome do arquivo é o último parâmetro fornecido no comando de compilação.

Você pode verificar os parâmetros que vão para -cp por meio das seguintes etapas:

1. Abra o prompt de comando.
2. Digite javac e pressione ENTER.
3. Todas as opções relevantes aparecem, incluindo -cp. Você descobrirá que -cp vem com um parâmetro em que o caminho é o caminho dos arquivos de classe que a JVM procura.

Captura de tela abaixo:

Como compilar vários arquivos ao mesmo tempo?

Vários arquivos de teste JUnit podem ser compilados de uma vez, separando os nomes dos arquivos com espaços.

A seguir está um exemplo de onde você compila arquivos java JUnitProgram e demoTest:

# 5.2) Como executar um teste JUnit na linha de comando?

Assim como javac é o compilador Java usado, da mesma forma java -cp é usado para executar os arquivos de classe Java, incluindo as classes JUnit.

Abaixo está a sintaxe que você pode seguir:

Este comando executa os arquivos JUnitProgram.java e demoTest.java um após o outro.

# 5.3) Informações adicionais sobre 'execução de linha de comando'.

ferramenta de reparo de software windows 10

Aqui estão algumas informações adicionais sobre como consertar um erro com o comando javac e por que usar a opção de execução de linha de comando

# 5.3.1) Como posso corrigir o erro de comando não reconhecido para o comando javac?

A maioria de nós enfrentaria esse problema ao tentar executar o Javac comando através da linha de comando. Isso aconteceu comigo também; então pensamos em escrevê-lo aqui.

para) Entramos no comando Javac e pressionado Digitar no prompt de comando.

b) A mensagem de erro - javac não é reconhecido como um comando interno ou externo, programa operável ou arquivo em lote apareceu como abaixo:

É aqui que começa a compilação dos arquivos de classe Java da linha de comando. Portanto, o erro é realmente um motivo de preocupação e não pode ser ignorado.

Para corrigir o problema, siga as etapas abaixo e Aqui está!!! você vê que o erro desapareceu:

• Vamos demonstrar esse processo usando um arquivo Java básico. A primeira etapa que você pode fazer é criar uma classe Java básica Por exemplo. : “Calculator.java”
• Devemos localizar Calculate.java no Windows Explorer e copiar o caminho.

• Altere o diretório no prompt de comando para o caminho que você copiou (o caminho do arquivo de origem). Use cd para mudar o diretório.

• Agora defina o PATH para a pasta bin jdk usando o comando.

SET PATH = e pressione ENTER.

• Aqui, o caminho jdk é C: Arquivos de programas Java jdk1.8.0_181 bin. Portanto, definimos o caminho de acordo. O resultante não mostra nada ao pressionar ENTER após o comando.

• Agora, verifique se a JVM reconhece o comando Javac inserindo o comando javac e pressionando ENTER.

1. 1. Se ele reconhecer o comando, um conjunto de opções válidas para javac será exibido como resultante.
   2. Caso contrário, o erro aparecerá novamente.

Abaixo está uma captura de tela mostrando que nos livramos do erro com sucesso.

Não vamos tentar iludir uma questão essencial aqui:

Por que a JVM reconheceu o comando javac depois de definir o caminho para a pasta jdk bin?

Temos certeza de que você também terá essa pergunta em mente. Dada a seguir está a resposta.

• A pasta jdk bin possui todas as bibliotecas para o comando javac. Portanto, é por isso que, ao definir o caminho de acordo, a JVM agora é capaz de reconhecer o comando javac sem nenhum problema.
• Veja o pasta javac sob o bin jdk na imagem abaixo.

• Você pode, então, executar o comando 'Java compilar e executar' usando a linha de comando. Além disso, lembre-se também de definir a variável CLASSPATH apropriadamente. Variáveis ​​JAVA_HOME e JUNIT_HOME para arquivos Java e arquivos JUnit, respectivamente.

# 5.3.2) Vantagem de executar testes usando a linha de comando:

Vamos discutir rapidamente a vantagem sobre a execução de casos de teste Java / JUnit por meio da linha de comando.

Como você já sabe, não existe uma regra rígida e rápida para a execução dos arquivos de classe através da linha de comando. É apenas uma forma alternativa de gerenciar a compilação e execução dos arquivos de classe.

Se você perguntar se há uma vantagem especial em ter know-how na execução dos testes JUnit via linha de comando, diremos 'Certamente, sim'.

O motivo para um 'Sim' é fornecido abaixo:

1. Todas essas séries de etapas que seguimos acima; pode ser adicionado ao bloco de notas e convertido em um arquivo em lote.
2. Agora, quando você executa esse arquivo em lote com um clique duplo, ele pode acionar a compilação e a execução de vários arquivos de teste JUnit nomeados no arquivo em lote.

Qual é a vantagem de ter um arquivo em lote para compilar e executar os arquivos Java?

1. Um arquivo batch / jar pode atuar como um utilitário amigável que pode permitir que qualquer pessoa não tenha conhecimento da lógica interna do código e execute vários casos de teste com muita facilidade.
2. Isso pode eliminar a necessidade de um desenvolvedor especializado ou QA para fazer esses trabalhos de execução de teste. A tarefa de execução pode ser delegada a qualquer recurso sem se preocupar com as restrições de habilidade.

Na próxima opção alternativa, veremos outra maneira vantajosa e recomendável de executar nossos casos de teste JUnit.

# 6) Execute o conjunto de testes usando a classe Testrunner

Em cenários de tempo real, executar um caso de teste por vez é a opção menos preferida.

• Temos casos em que precisamos executar um grupo de casos de teste relacionados / não relacionados.
• Por exemplo, podemos precisar criar e executar suítes de teste de regressão ou suítes de teste de fumaça.

Agora aprenderemos sobre a implementação de diferentes anotações usadas para criar suítes de teste e executar a suíte.

O processo geral de execução do conjunto de testes usando o Test Runner é conforme o fluxo de trabalho abaixo:

1. Crie JUnit classe 1, JUnit classe 2,…. JUnit class n.
2. Crie o arquivo de classe do conjunto de testes agrupando os casos de teste.
3. Crie um arquivo de classe Testrunner para invocar o conjunto de testes criado.
4. Execute a classe Testrunner.

A estrutura dos programas através dos quais demonstraremos a criação do conjunto de testes e a execução do arquivo runner é mostrada na imagem abaixo:

Aqui, cobriremos os subtópicos:

1. Criação de classes JUnit
2. Criando suítes de teste
3. Criar um arquivo Testrunner e executar as suítes de teste usando-o.
4. Informações adicionais sobre o funcionamento da anotação @RunWith.

# 6.1) Criação de classes JUnit

Vamos começar criando dois arquivos de classe JUnit simples:

1. JUnitTestCase1.java - Inclui o código para verificar um valor numérico esperado - a variável Value1 corresponde a um valor real da variável Value2.
2. JUnitTestCase2.java - Inclui o código para verificar se a variável de string esperada strValue e a variável de string real strActual partidas.

Esses são basicamente dois casos de teste que tentaremos colocar em um agrupamento lógico chamado suíte de teste e fazê-lo rodar um após o outro.

Código para JUnitTestCase1.java

Código para JUnitTestCase2.java

# 6.2) Criando suíte de teste:

Esta seção e a próxima têm um papel importante em todo o processo de criação e execução de um conjunto de testes. Nesta seção, tentaremos entender como agrupar várias classes de teste JUnit e vinculá-las a um conjunto de testes .

Conforme a imagem estrutural acima, vamos criar um conjunto de testes agrupando JUnitTestCase1.java e JUnitTestCase2.java e nomear o conjunto como JUnitTestSuite.java

As duas anotações que nos ajudam a conseguir a criação de um conjunto de testes são:

1. @RunWith e
2. @SuiteClasses

Pacotes necessários para as anotações:

1. Você precisará importar o pacote org.junit.runner.RunWith; para a inclusão da anotação @RunWith.
2. Você precisará do pacote org.junit.runners.Suite.SuiteClasses para que @SuiteClasses funcione.
3. Além disso, você também precisará importar o pacote org.junit.runners.Suite para passar um parâmetro Suite.class para a anotação @RunWith.

Vamos dar uma olhada no código para um melhor entendimento !!

Código para JUnitTestSuite.java

Compreensão do código para JUnitTestSuite.java:

1. @RunWith ajuda a JVM a entender que tipo de classe de execução deve ser executada Por exemplo. Suite.class ou Cucumber.class
2. Aqui, o parâmetro de @RunWith é Suite.class . Isso ajuda a JVM a reconhecer que o arquivo atual onde @RunWith (Suite.class) é usado desempenha uma função no Test Suite.
3. Os nomes das classes de teste JUnit a serem vinculados em um conjunto devem ser passados ​​como uma matriz de string na forma de parâmetros para @SuiteClasses cada um separado por uma vírgula.
4. Isso permite que a JVM saiba quais são todos os casos de teste que precisam ser agrupados no conjunto.
5. O nome do conjunto será o nome do arquivo da classe JUnit que é anotado com @RunWith e @SuiteClasses que é JUnitTestSuite neste caso.

# 6.3) Crie o arquivo Test Runner e execute o conjunto de testes JUnit usando o Test Runner

A última etapa nos ajudará a executar o conjunto de testes que acabamos de criar na seção acima usando um arquivo Testrunner.

1. Agora criaremos um arquivo Java denominado SuiteRunnerFile.
2. Este SuiteRunnerFile.java não é uma classe JUnit, mas um arquivo Java normal com o método principal nele.

Vamos examinar o código e tentar entendê-lo.

Código para SuiteRunnerFile.java

Pacotes necessários para a anotação

1. Você precisa importar o pacote org.junit.runner.JunitCore para incluir o JUnitCore classe no código.
2. Você precisa importar o pacote org.junit.runner.notification.Failure e org.junit.runner. Resultado para incluir as classes Falha e Resultado no código, respectivamente.

Compreensão do código para SuiteRunnerFile.java

1. Para criar um arquivo runner para a execução do conjunto de testes, o JUnitCore classe desempenha um papel significativo.
2. O runClasses () método de JUnitCore class recebe o nome da classe do conjunto de testes como parâmetro de entrada, portanto, temos a instrução JUnitCore. runClasses (JUnitTestSuite. aula )
3. O tipo de retorno desta declaração é o Resultado objeto de classe que armazena o status de sucesso resultante e o status de falha de cada arquivo de caso de teste; pós-execução. É por isso que temos um resultado Enquanto o Resultado objeto de classe no código.
4. Em seguida, imprimimos as falhas dos casos de teste, se houver. Como o método getFailures (), você também pode obter a contagem de falhas e a contagem de execução usando o método getFailureCount () e getRunCount (), respectivamente.
5. Agora SuiteRunnerFile está pronto para ser executado,
   1. Selecione o arquivo no Package Explorer e
   2. Clique com o botão direito e selecione Executar como -> Java, o programa é executado.

A seguir está a captura de tela da janela do console.

Explicação dos resultados no console:

O console acima mostra que:

1. O arquivo de classe JUnitTestSuite foi executado por meio do SuiteRunnerFile.
2. O método printMe () sob a anotação @BeforeClass executado primeiro e
3. Em seguida, os casos de teste no suite de teste foram executados um após o outro. É assim que o conjunto de testes pode ser criado e executado como um pacote.

# 6.4) Informações adicionais - Como funciona o @RunWith?

• @RunWith é uma API JUnit que basicamente usa apenas um elemento como um parâmetro de entrada que é um nome de arquivo de classe de execução.
• A estrutura JUnit chama a classe especificada como um executor de teste.

O snippet de RunWith.java abaixo o ajudará a entender:

Compreendendo o código da interface RunWith acima:

1. O especificado valor elemento deve ser uma classe derivada do Corredor aula . O conceito de reflexão é usado aqui.
2. Um bom exemplo de uma classe de runner já está implementado em nosso código, ou seja, @RunWith (Suite.class) onde um grupo de casos de teste é ligado para formar um conjunto de testes.
3. Da mesma forma, outro bom exemplo de uso de uma classe Runner com @RunWith poderia ser @RunWith (Cucumber.class), que é uma estrutura de desenvolvimento orientado a negócios (BDD) para automação de teste usando Selenium em Java. Isso ajuda a estrutura a executar os casos de teste baseados no Cucumber.

Observação:

• As anotações e parâmetros usados ​​para criar e executar o conjunto de testes JUnit neste tutorial eram específicos para JUnit 4.
• Há uma maneira um pouco diferente de como você cria um JUnit Test Suite e executa o arquivo runner no JUnit 5.

Teremos uma compreensão focada de todos os aspectos do JUnit 4 vs JUnit 5 em breve em nossos próximos tutoriais.

# 7) Executar casos de teste JUnit usando Maven

Você também pode ter um projeto Maven que consiste em testes JUnit em vigor e executar os testes por meio do Maven, que serão abordados em um tutorial separado.

Conclusão

1. Aprendemos todas as diferentes opções para executar os testes JUnit - testes únicos, bem como vários outros agrupados em suítes de teste.
2. Nós obtivemos conhecimento adicional sobre como atualizar a preferência pela opção Executar, como consertar o erro do javac e como a execução da linha de comando pode nos ajudar.
3. Além disso, também aprendemos como funciona a anotação @RunWith.

Portanto, há mais a seguir nos próximos tutoriais. ‘Aguarde’ até então !!!

=> Visite aqui para aprender JUnit do zero.

Leitura recomendada

• Testes JUnit: como escrever casos de teste JUnit com exemplos
• Tutorial JUnit para iniciantes - O que é teste JUnit
• O que é um dispositivo de teste JUnit: Tutorial com exemplos JUnit 4
• Relatórios de Specflow: como gerar relatórios de teste e executar testes seletivos
• Baixe, instale e configure JUnit no Eclipse
• Introdução ao JUnit Framework e seu uso no Selenium Script - Selenium Tutorial # 11
• Crie testes de Appium para um aplicativo Android
• Insira vários documentos no MongoDB usando matrizes