Desejo executar métodos de teste anotados por @Test
ordem específica.
Por exemplo:
public class MyTest {
@Test public void test1(){}
@Test public void test2(){}
}
Quero garantir a execução test1()
antes de test2()
cada vez que corro MyTest
, mas não consegui encontrar anotações como essa @Test(order=xx)
.
Eu acho que é um recurso muito importante para o JUnit, se o autor do JUnit não deseja o recurso de pedido , por quê?
java
unit-testing
junit
junit4
卢 声 远 Shengyuan Lu
fonte
fonte
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
, manter a@Test
anotação de todos os métodos de ensaio e renomeá-los em ordem alfabética de acordo com a ordem desejada de execução, por exemplot1_firstTest()
,t2_secondTest()
, etc.Respostas:
Não tenho certeza de que haja uma maneira limpa de fazer isso com o JUnit, pelo que sei, o JUnit assume que todos os testes podem ser executados em uma ordem arbitrária. Do FAQ:
Por que é tão? Bem, acredito que tornar a ordem dos testes dependente é uma prática que os autores não querem promover. Os testes devem ser independentes, não devem ser acoplados, e violar isso tornará as coisas mais difíceis de manter, prejudicará a capacidade de executar testes individualmente (obviamente) etc.
Dito isto, se você realmente quiser ir nessa direção, considere usar o TestNG, pois ele suporta a execução de métodos de testes em qualquer ordem arbitrária nativamente (e coisas como especificar que métodos dependem de grupos de métodos). Cedric Beust explica como fazer isso em ordem de execução de testes no testng .
fonte
Se você se livrar da sua instância existente do Junit e fizer o download do JUnit 4.11 ou superior no caminho de construção, o código a seguir executará os métodos de teste na ordem de seus nomes, classificados em ordem crescente:
fonte
@Inherited
e, portanto, se torna ineficaz na minhaAbstractTestCase
classe pai.Se o pedido for importante, faça você mesmo.
Em particular, você deve listar algumas ou todas as permutações de pedidos possíveis para testar, se necessário.
Por exemplo,
Ou, um teste completo de todas as permutações:
Aqui
permute()
está uma função simples que itera todas as permutas possíveis em uma coleção de array.fonte
test2
é executadotest1
novamente . Junit ainda pode ser executadotest2
antestest1
. Provavelmente, isso não é o que você pretendia e não é uma resposta válida para a pergunta.A migração para o TestNG parece a melhor maneira, mas não vejo uma solução clara aqui para o jUnit. Aqui está a solução / formatação mais legível que encontrei para o jUnit:
Isso garante que os métodos stage2 sejam chamados após os stage1 e antes dos stage3.
fonte
0
prefixo, por exemplovoid stage01_prepareAndTest(){ }
Esse é um dos principais problemas que eu enfrentei quando trabalhei no Junit e criei a seguinte solução, que funciona bem para mim:
Também crie uma interface como abaixo:
Agora, suponha que você tenha a classe A em que você escreveu vários casos de teste como abaixo:
Portanto, a execução começará no método chamado "method ()". Obrigado!
fonte
@RunWith(PowerMockRunner.class) @PowerMockRunnerDelegate(OrderedRunner.class)
Atualmente, o JUnit permite que métodos de teste executem a ordenação usando anotações de classe:
Por padrão, os métodos de teste são executados em ordem alfabética. Portanto, para definir métodos específicos, você pode nomeá-los como:
Você pode encontrar exemplos aqui .
fonte
A alteração (ainda não lançada) https://github.com/junit-team/junit/pull/386 apresenta a
@SortMethodsWith
. https://github.com/junit-team/junit/pull/293 pelo menos tornou a ordem previsível sem isso (no Java 7, pode ser bastante aleatório).fonte
@FixMethodOrder
não é chamado@SortMethodsWith
em 4.11Veja um relatório JUnit. O JUnit já está organizado por pacote. Cada pacote possui (ou pode ter) classes TestSuite, cada uma das quais, por sua vez, executa vários TestCases. Cada TestCase pode ter vários métodos de teste do formulário
public void test*()
, cada um dos quais realmente se tornará uma instância da classe TestCase à qual eles pertencem. Cada método de teste (instância TestCase) possui um nome e um critério de aprovação / reprovação.O que meu gerenciamento exige é o conceito de itens individuais do TestStep , cada um deles relatando seus próprios critérios de aprovação / reprovação. A falha de qualquer etapa do teste não deve impedir a execução das etapas subseqüentes.
No passado, os desenvolvedores de testes em minha posição organizavam as classes TestCase em pacotes que correspondiam às partes do produto em teste, criavam uma classe TestCase para cada teste e tornavam cada método de teste uma "etapa" separada no teste, complete com seus próprios critérios de aprovação / reprovação na saída JUnit. Cada TestCase é um "teste" independente, mas os métodos individuais, ou "etapas" de teste no TestCase, devem ocorrer em uma ordem específica.
Os métodos do TestCase foram as etapas do TestCase, e os projetistas de testes obtiveram um critério de aprovação / reprovação separado por etapa do teste. Agora as etapas do teste são confusas e os testes (é claro) falham.
Por exemplo:
Cada método de teste afirma e reporta seus próprios critérios de aprovação / reprovação separados. Colocar isso em "um grande método de teste" para fins de pedido perde a granularidade dos critérios de aprovação / reprovação de cada "etapa" no relatório de resumo da JUnit. ... e isso incomoda meus gerentes. Atualmente, eles estão exigindo outra alternativa.
Alguém pode explicar como uma JUnit com ordenação de método de teste codificado suportaria critérios de aprovação / reprovação separados de cada etapa de teste seqüencial, como exemplificado acima e exigido por minha gerência?
Independentemente da documentação, vejo isso como uma regressão séria na estrutura do JUnit que está dificultando a vida de muitos desenvolvedores de teste.
fonte
Atualização do JUnit 5 (e minha opinião)
Por padrão, as bibliotecas de teste de unidade não tentam executar testes na ordem que ocorre no arquivo de origem.
JUnit 5 como JUnit 4 funcionam dessa maneira. Por quê ? Porque se a ordem importa, significa que alguns testes são acoplados entre eles e isso é indesejável para testes de unidade .
Portanto, o
@Nested
recurso introduzido pelo JUnit 5 segue a mesma abordagem padrão.Mas para testes de integração, a ordem do método de teste pode ser importante, pois um método de teste pode alterar o estado do aplicativo da maneira esperada por outro método de teste. Por exemplo, quando você escreve um teste de integração para um processamento de check-out de e-shop, o primeiro método de teste a ser executado é o registro de um cliente, o segundo é a adição de itens na cesta e o último é o checkout. Se o executor do teste não respeitar essa ordem, o cenário de teste será defeituoso e falhará.
Portanto, no JUnit 5 (da versão 5.4), você tem a mesma possibilidade de definir a ordem de execução, anotando a classe de teste
@TestMethodOrder(OrderAnnotation.class)
e especificando a ordem@Order(numericOrderValue)
para os métodos relevantes para a ordem.Por exemplo :
Resultado :
A propósito, especificar
@TestMethodOrder(OrderAnnotation.class)
não parece necessário (pelo menos na versão 5.4.0 que testei).Nota lateral
Sobre a pergunta: o JUnit 5 é a melhor opção para escrever testes de integração? Eu não acho que ela deva ser a primeira ferramenta a ser considerada (pepino e companhia podem trazer valor e recursos mais específicos para testes de integração), mas em alguns casos de teste de integração, a estrutura JUnit é suficiente. Portanto, é uma boa notícia que o recurso existe.
fonte
Não tenho certeza se concordo. Se eu quiser testar o 'Upload de arquivo' e depois o teste 'Dados inseridos pelo upload de arquivo', por que não gostaria que eles fossem independentes um do outro? Perfeitamente razoável, acho que posso executá-los separadamente, em vez de ter os dois em um caso de teste de Golias.
fonte
O que você deseja é perfeitamente razoável quando os casos de teste estão sendo executados como um conjunto.
Infelizmente, não há tempo para dar uma solução completa no momento, mas veja a classe:
O que permite chamar casos de teste (de qualquer classe de teste) em uma ordem específica.
Eles podem ser usados para criar testes funcionais, de integração ou de sistema.
Isso deixa os testes de unidade como estão, sem ordem específica (conforme recomendado), independentemente de você ser executado dessa maneira ou não e depois reutilizar os testes como parte de uma imagem maior.
Reutilizamos / herdamos o mesmo código para testes de unidade, integração e sistema, às vezes orientados a dados, às vezes orientados por confirmação e às vezes executados como um conjunto.
fonte
Veja minha solução aqui: "Junit e java 7."
Neste artigo, descrevo como executar testes junit em ordem - "como no seu código-fonte". Os testes serão executados, na ordem em que seus métodos de teste aparecerem no arquivo de classe.
http://intellijava.blogspot.com/2012/05/junit-and-java-7.html
Mas, como disse Pascal Thivent, essa não é uma boa prática.
fonte
Com o JUnit 5.4, você pode especificar a ordem:
você só precisa anotar sua turma
https://junit.org/junit5/docs/current/user-guide/#writing-tests-test-execution-order
Estou usando isso no meu projeto e funciona muito bem!
fonte
Li algumas respostas e concordo que não é uma prática recomendada, mas a maneira mais fácil de solicitar seus testes - e a maneira como o JUnit executa testes por padrão é pelo nome alfabético crescente.
Então, apenas nomeie seus testes na ordem alfabética desejada. Observe também que o nome do teste deve começar com a palavra teste. Cuidado com os números
test12 será executado antes do test2
tão:
testA_MyFirstTest testC_ThirdTest testB_ATestThatRunsSecond
fonte
Confira este: https://github.com/TransparentMarket/junit . Ele executa o teste na ordem em que são especificados (definidos no arquivo de classe compilado). Também possui um conjunto AllTests para executar testes definidos primeiro pelo subpacote. Usando a implementação AllTests, pode-se estender a solução também filtrando propriedades (costumávamos usar anotações @Fast, mas essas ainda não foram publicadas).
fonte
Aqui está uma extensão do JUnit que pode produzir o comportamento desejado: https://github.com/aafuks/aaf-junit
Sei que isso é contrário aos autores da filosofia JUnit, mas ao usar o JUnit em ambientes que não são estritamente testes de unidade (como praticado em Java), isso pode ser muito útil.
fonte
Acabei aqui pensando que meus testes não foram executados em ordem, mas a verdade é que a bagunça estava nos meus trabalhos assíncronos. Ao trabalhar com simultaneidade, você também deve executar verificações de simultaneidade entre seus testes. No meu caso, trabalhos e testes compartilham um semáforo, portanto, os próximos testes são interrompidos até que o trabalho em execução libere o bloqueio.
Sei que isso não está totalmente relacionado a esta pergunta, mas talvez possa ajudar a direcionar o problema correto
fonte
você pode usar um destes códigos:
fonte