JUnit vs TestNG [fechado]

No trabalho, ainda estamos usando o JUnit 3 para executar nossos testes. Estávamos pensando em mudar para o JUnit 4 para novos testes sendo escritos, mas eu estou de olho no TestNG há um tempo. Quais experiências vocês já tiveram com o JUnit 4 ou o TestNG e quais parecem funcionar melhor em um número muito grande de testes? Ter flexibilidade na escrita de testes também é importante para nós, pois nossos testes funcionais abrangem um aspecto amplo e precisam ser escritos de várias maneiras para obter resultados.

Os testes antigos não serão reescritos, pois eles fazem seu trabalho muito bem. O que eu gostaria de ver em novos testes é a flexibilidade na maneira como o teste pode ser escrito, asserções naturais, agrupamentos e execuções de teste facilmente distribuídas.

Eu usei os dois, mas tenho que concordar com Justin Standard que você não deve realmente reescrever seus testes existentes para qualquer novo formato. Independentemente da decisão, é bastante trivial executar as duas. O TestNG se esforça para ser muito mais configurável que o JUnit, mas no final ambos funcionam igualmente bem.

O TestNG possui um recurso interessante, no qual você pode marcar testes como um grupo específico e executar facilmente todos os testes de um grupo específico ou excluir testes de um grupo específico. Assim, você pode marcar os testes que são executados lentamente como no grupo "lento" e depois ignorá-los quando desejar resultados rápidos. Uma sugestão da documentação deles é marcar alguns subconjuntos como testes de "check-in", que devem ser executados sempre que você fizer o check-in de novos arquivos. Nunca vi esse recurso no JUnit, mas, se você não o tiver, não precisará " Realmente sinto falta.

Por todas as suas reivindicações de alta configuração, encontrei uma caixa de esquina há algumas semanas atrás, onde não podia fazer o que queria ... queria lembrar o que é, mas queria trazê-lo à tona então você sabe que não é perfeito.

A maior vantagem do TestNG são as anotações ... que a JUnit adicionou na versão 4 de qualquer maneira.

Primeiro eu diria, não reescreva todos os seus testes apenas para se adequar à última moda. O Junit3 funciona perfeitamente bem, e a introdução de anotações no 4 não o comprará muito (na minha opinião). É muito mais importante que vocês escrevam testes, e parece que você faz.

Use o que parecer mais natural e o ajudará a realizar seu trabalho.

Não posso comentar no TestNG b / c que não o usei. Mas eu recomendaria o unitils , um ótimo invólucro para o JUnit / TestNG / DBUnit / EasyMock, independentemente da rota que você seguir. (Ele suporta todos os sabores mencionados acima)

Os maiores cartões de aposta do TestNG para mim incluem seus grupos de teste de suporte e, mais importante - dependências de grupo de teste (marcar um teste como dependente de um grupo faz com que os testes simplesmente pulem a execução quando o grupo dependente falha).

Os outros grandes cartões de teste da TestNG para mim incluem parâmetros de teste, provedores de dados, transformadores de anotações e mais do que tudo - a comunidade de usuários vibrante e receptiva.

Enquanto na superfície não se pode pensar que todos os recursos do TestNGs acima possam não ser necessários, quando você começar a entender a flexibilidade que você traz para os seus testes, você se perguntará como lidou com o JUnit.

(isenção de responsabilidade - eu não usei o JUnit 4.x, por isso não consigo comentar realmente sobre os avanços ou novos recursos).

Há cerca de um ano, tivemos o mesmo problema. Passei algum tempo pensando em qual jogada era melhor e, finalmente, percebemos que o TestNG não possui 'recursos matadores'. É legal e possui alguns recursos que o JUnit 4 não possui, mas não precisamos deles.
Não queríamos que as pessoas se sentissem desconfortáveis ​​ao escrever testes ao conhecer o TestNG porque queríamos que continuassem escrevendo muitos testes.
Além disso, o JUnit é praticamente o padrão de fato no mundo Java. Não existe uma ferramenta decente que não seja compatível com ele, você pode encontrar muita ajuda na Web e eles adicionaram muitos novos recursos no ano passado, o que mostra que ele está vivo.

Decidimos ficar com o JUnit e nunca mais olhamos para trás.

Um brinde a todos os itens acima. Algumas outras coisas que eu pessoalmente achei que gosto mais no TestNG são:

1. O @BeforeClassfor TestNG ocorre após a criação da classe, portanto você não é limitado apenas por chamar métodos estáticos da sua classe.

2. Testes paralelos e parametrizados, talvez eu não tenha vida o suficiente ... mas eu recebo um chute ao escrever um conjunto de testes de Selenium, aceitando um nome de driver como parâmetro. Depois, defina 3 grupos de testes paralelos, 1 para os pilotos do IE, FF e Chrome, e assista à corrida! Originalmente fiz 4, mas muitas das páginas em que trabalhei quebraram o HtmlUnitdriver por um motivo ou outro.

Sim, provavelmente precisa encontrar essa vida. ;)

Eu queria compartilhar o que encontrei hoje. Descobri que o corredor parametrizado interno é bastante rude no Junit4, em comparação com o TestNG (eu sei que cada estrutura tem seus pontos fortes, mas ainda assim). A anotação Junit4 @parameters é restrita a um conjunto de parâmetros. Encontrei esse problema ao testar o comportamento válido e inválido para funcionalidade na mesma classe de teste. Portanto, o primeiro método público anotado estático que encontrar será usado, mas poderá encontrá-los em qualquer ordem. Isso nos leva a escrever diferentes classes desnecessariamente. No entanto, o TestNG fornece uma maneira limpa de fornecer diferentes tipos de provedores de dados para cada método. Portanto, podemos testar a mesma unidade de código de maneira válida e inválida na mesma classe de teste, colocando os dados válidos / inválidos separadamente. Eu irei com o TestNG.

Também mais uma vantagem do TestNG é o suporte a testes paralelos. Na nossa era dos multicores, é importante, eu acho.

Eu também usei os dois frameworks. Mas eu estou usando hamcrest para afirmações. O Hamcrest permite que você escreva facilmente seu próprio método de afirmação. Então, ao invés de

assertEquals(operation.getStatus(), Operation.Status.Active);

Você pode escrever

assertThat(operation, isActive());

Isso lhe dá a oportunidade de usar um nível mais alto de abstração em seus testes. E isso torna seus testes mais robustos.

JUnit 4 Vs TestNG - Comparação por mkyong.com (atualizada em 2013).

Conclusão: Sugiro usar o TestNG como estrutura de teste da unidade principal para o projeto Java, porque o TestNG é mais avançado em parametrizar testes, testes de dependência e testes de suíte (conceito de agrupamento).

TestNG destina-se a testes funcionais de alto nível e testes de integração complexos. Sua flexibilidade é especialmente útil em grandes suítes de teste.

Além disso, o TestNG também abrange toda a funcionalidade principal do JUnit4 . Simplesmente não há mais razão para eu usar o JUnit.

Em termos simples, TestNG = JUnit + muito mais. Então, por que debater? vá e pegue o TestNG :-)

Você pode encontrar uma comparação mais detalhada aqui .

Algumas adições à resposta de Mike Stone:

1) A coisa mais frequente para a qual eu uso os grupos do TestNG é quando eu quero executar um único método de teste em um conjunto de testes. Simplesmente adiciono este teste ao grupo "phil" e, em seguida, corro esse grupo. Quando eu estava usando o JUnit 3, eu comentava as entradas de todos os métodos, exceto o que eu queria executar no método "suite", mas geralmente esquecia de descomentá-las antes do check-in. Com os grupos, não tenho mais esse problema.

2) Dependendo da complexidade dos testes, a migração de testes do JUnit3 para o TestNG pode ser feita de maneira automática com o sed e criando uma classe base para substituir o TestCase que estático importa todos os métodos de declaração do TestNG.

Tenho informações sobre minha migração do JUnit para o TestNG aqui e aqui .

Por que usamos o TestNG em vez do JUnit?

1. A declaração @BeforeClasse o @AfterClassmétodo devem ser estáticos no JUnit, enquanto que no TestNG há mais flexibilidade na declaração do método, ele não possui essas restrições.

2. No TestNG, podemos parametrizar testes usando duas maneiras . Anotação @Parameter ou @DataProvider.

   i) @Parameter para casos simples, onde o mapeamento de valores-chave é necessário. (os dados são fornecidos através do arquivo xml)

   ii) @DataProvider para casos complexos. Usando matriz bidimensional, pode fornecer dados.

3. No TestNG, como o método @DataProvider não precisa ser estático, podemos usar vários métodos de provedor de dados na mesma classe de teste.

4. Teste de dependência: No TestNG, se o teste inicial falhar, todos os testes dependentes subsequentes serão ignorados, não marcados como com falha. Mas a JUnit marcou que falhou.

5. Agrupamento: testes únicos podem pertencer a vários grupos e, em seguida, executados em diferentes contextos (como testes lentos ou rápidos). Um recurso semelhante existe nas Categorias JUnit, mas não possui as anotações @BeforeGroups / @AfterGroups TestNG que permitem inicializar o teste / derrubá-lo.

6. Paralelismo: se você deseja executar o mesmo teste em paralelo em vários threads, o TestNG oferece uma anotação simples de usar, enquanto o JUnit não oferece uma maneira simples de fazê-lo imediatamente.

7. O TestNG @DataProvider também pode suportar XML para alimentar dados, CSVs ou até arquivos de texto sem formatação.

8. TestNG permite declarar dependências entre testes e ignorá-las se o teste de dependência não passou.

@Test (dependeOnMethods = {"dependOnSomething"})

Essa funcionalidade não existe no JUnit

9. Comunicando:

Os relatórios TestNG são gerados por padrão em uma pasta de saída de teste que inclui relatórios HTML com todos os dados de teste, aprovados / reprovados / ignorados, por quanto tempo eles foram executados, qual entrada foi usada e os logs de teste completos. Além disso, ele também exporta tudo para um arquivo XML que pode ser usado para construir seu próprio modelo de relatório.

No front JUnit, todos esses dados também estão disponíveis via XML, mas não há um relatório pronto para uso e você precisa confiar em plug-ins.

Link do recurso:

1. Uma comparação rápida JUnit vs TestNG
2. JUnit vs. TestNG: qual estrutura de teste você deve escolher?

Uma boa diferença é dada neste tutorial lado a lado: TestNG Vs JUnit: Qual é a diferença?

Sua pergunta parece dobrada para mim. Por um lado, você gostaria de comparar duas estruturas de teste, por outro lado, gostaria de implementar testes facilmente, ter afirmações naturais, etc ...

Ok, em primeiro lugar, o JUnit está tentando recuperar o atraso com o TestNG em termos de funcionalidade, eles preenchem a lacuna em alguns aspectos com a v4, mas não na minha opinião. Coisas como anotações e provedores de dados ainda são muito melhores no TestNG. Também são mais flexíveis em termos de execução de teste, pois o TestNG possui dependência, agrupamento e ordenação de teste.

O JUnit ainda exige que certos métodos antes / depois sejam estáticos, o que limita o que você pode fazer antes da execução dos testes, o TestNG nunca tem esse problema.

TBH, principalmente as diferenças entre as duas estruturas não significam muito, a menos que você se concentre nos testes de integração / automação. A partir da minha experiência, a JUnit foi criada desde o início para testes de unidade e agora está sendo levada a níveis mais altos de testes, o que a IMO a torna a ferramenta errada para o trabalho. O TestNG se sai bem em testes de unidade e, devido ao seu robusto fornecimento de dados e excelentes habilidades de execução de testes, funciona ainda melhor no nível de integração / automação.

Agora, para o que acredito ser uma questão separada, como escrever testes bem estruturados, legíveis e de manutenção. Tenho certeza de que você sabe muito sobre isso, mas coisas como Padrão de Fábrica , Padrão de Comando e PageObjects (se os sites de teste) são vitais, é muito importante ter uma camada de abstração entre o que o teste (SUT) e o teste real é (asserções da lógica de negócios). Para ter afirmações muito mais agradáveis, você pode usar o Hamcrest . Faça uso da herança / interfaces de javas para reduzir a repetição e reforçar a semelhança.

Quase esqueci, também use o Test Data Builder Pattern , que, juntamente com a anotação do provedor de dados do TestNG, é muito útil.

Minha opinião sobre o que torna o TestNG realmente muito mais poderoso:

1.  JUnit still requires the before/after class methods to be static, which limits
    what you can do prior to the running of tests, TestNG never has this issue.

2.  TestNG @Configuration methods can all take an optional argument to their 
    annotated methods in the form of a ITestResult, XmlTest, Method, or 
    ITestContext.  This allows you to pass things around that JUnit wouldn't 
    provide you.  JUnit only does this in listeners and it is limited in use.

3.  TestNG comes with some pre-made report generation classes that you can copy
     and edit and make into your own beautiful test output with very little 
     effort. Just copy the report class into your project and add a listener 
     to run it.  Also, ReportNG is available.

4.  TestNG has a handful of nice listeners that you can hook onto so you can do
     additional AOP style magic at certain phases during testing.