JUnit vs TestNG

Primero diría, no reescriba todas sus pruebas solo para adaptarse a la última moda. Junit3 funciona perfectamente bien, y la introducción de anotaciones en 4 no te compra mucho (en mi opinión). Es mucho más importante que ustedes escriban pruebas, y suena como si lo hicieran.

Usa lo que parezca más natural y te ayude a hacer tu trabajo.

No puedo comentar sobre TestNG b/c No lo he usado. Pero yo recomendaría unitils , un gran envoltorio para JUnit / TestNG/DBUnit / EasyMock, independientemente de la ruta que tome. (Es compatible con todos los sabores mencionados anteriormente)

Hace aproximadamente un año, tuvimos el mismo problema. Pasé algún tiempo considerando qué movimiento era mejor, y finalmente nos dimos cuenta de que TestNG no tiene "características asesinas". Es agradable, y tiene algunas características que JUnit 4 no tiene, pero no las necesitamos.
No queríamos que la gente se sintiera incómoda escribiendo pruebas mientras se familiarizaba con TestNG porque queríamos que siguieran escribiendo muchas pruebas.
Además, JUnit es prácticamente el estándar de facto en el mundo Java. No hay ninguna herramienta decente que no es compatible desde la caja, puede encontrar mucha ayuda en la web y agregaron muchas características nuevas en el último año, lo que demuestra que está vivo.

Decidimos seguir con JUnit y nunca miramos atrás.

Las mayores cartas de sorteo de TestNG para mí incluyen sus grupos de prueba de soporte y, lo que es más importante, las dependencias de grupo de prueba (marcar una prueba como dependiente de un grupo hace que las pruebas simplemente omitan la ejecución cuando el grupo dependiente falla).

Otras tarjetas de gran atractivo de TestNG para mí incluyen parámetros de prueba, proveedores de datos, transformadores de anotación y, más que nada, la vibrante y receptiva comunidad de usuarios.

Mientras que en la superficie uno podría no pensar todos los TestNGs las características anteriores pueden no ser necesarias, una vez que comience a comprender la flexibilidad que aportan a sus pruebas, se preguntará cómo hizo frente a JUnit.

(descargo de responsabilidad - No he usado JUnit 4.x en absoluto, por lo que soy incapaz de comentar realmente sobre los avances o nuevas características allí).

Saludos a todo lo anterior. Algunas otras cosas que personalmente he encontrado que me gustan más en TestNG son:

1. El @BeforeClass para TestNG tiene lugar después de la creación de la clase, por lo que no está limitado por solo poder llamar a métodos estáticos de su clase en él.

2. Pruebas paralelas y parametrizadas, tal vez no tengo suficiente vida... pero acabo de obtener una patada escribiendo un conjunto de pruebas de Selenio, aceptando un nombre de controlador como parámetro. Luego definir 3 grupos de prueba paralelos, 1 cada uno para los pilotos de IE, FF y Chrome, y viendo la carrera! Originalmente hice 4, pero demasiadas de las páginas en las que he trabajado rompen el controlador HtmlUnit por una razón u otra.

Sí, probablemente necesite encontrar esa vida. ;)

Quería compartir el que encontré hoy. Encontré que el corredor parametrizado incorporado es bastante crudo en Junit4 en comparación con TestNG (sé que cada marco tiene sus fortalezas, pero aún así). Los parámetros de anotación @ de Junit4 están restringidos a un conjunto de parámetros. Encontré este problema mientras probaba el comportamiento válido e inválido para la funcionalidad en la misma clase de prueba. Así que se utilizará el primer método público, estático y anotado que encuentre, pero puede encontrarlos en cualquier orden. Esto nos causa para escribir diferentes clases innecesariamente. Sin embargo TestNG proporciona una forma limpia de proporcionar diferentes tipos de proveedores de datos para cada método. Así que podemos probar la misma unidad de código con forma válida e inválida en la misma clase de prueba poniendo los datos válidos/inválidos por separado. Iré con TestNG.

También una ventaja más de TestNG es el apoyo de pruebas paralelas. En nuestra era de multicores es importante, creo.

También utilicé ambos frameworks. Pero yo uso hamcrest para afirmaciones. Hamcrest le permite escribir fácilmente su propio método assert. Así que en lugar de

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

Puedes escribir

assertThat(operation, isActive());

Eso le da la oportunidad de usar un nivel más alto de abstracción en sus pruebas. Y esto hace que sus pruebas sean más robustas.

Un par de adiciones a la respuesta de Mike Stone:

1) Lo más frecuente para lo que uso los grupos de TestNG es cuando quiero ejecutar un único método de prueba en un conjunto de pruebas. Simplemente añado esta prueba al grupo "phil" y luego corro este grupo. Cuando estaba usando JUnit 3, comentaba las entradas para todos los métodos excepto el que quería ejecutar en el método "suite", pero luego comúnmente me olvidaba de descomentarlos antes de checkin. Con los grupos, ya no tengo este problema.

2) Dependiendo de la complejidad de las pruebas, migrar pruebas de JUnit3 a TestNG se puede hacer de forma algo automática con sed y crear una clase base para reemplazar TestCase que static importa todos los métodos TestNG assert.

Tengo información sobre mi migración de JUnit a TestNG aquíy aquí.

JUnit 4 Vs TestNG-Comparación por mkyong.com (actualizado en 2013).

Conclusión: Sugiero usar TestNG como framework de prueba de unidad central para el proyecto Java, porque TestNG es más avanzar en las pruebas de parametrización, las pruebas de dependencias y las pruebas de suite (concepto de agrupación).

TestNG está diseñado para pruebas funcionales, de alto nivel y pruebas de integración complejas. Su flexibilidad es especialmente útil con grandes conjuntos de pruebas.

Además, TestNG también cubre toda la funcionalidad del núcleo JUnit4 . Ya no es razón para usar a JUnit.

In simple terms, TestNG = JUnit + lot more...So, Why debate ? go and grab TestNG :-)

Puede encontrar una comparación más detallada aquí.

Me gusta la integración ordenada y fácil de TestNG con Guice.

Su pregunta me parece doble. Por un lado, le gustaría comparar dos marcos de prueba, por otro lado, le gustaría implementar pruebas fácilmente, tener aserciones naturales, etc...

Ok, en primer lugar JUnit ha estado jugando catchup con TestNG en términos de funcionalidad, que han cerrado la brecha algo que con v4, pero no lo suficientemente bien en mi opinión. Cosas como las anotaciones y los proveedores de datos siguen siendo mucho mejores en TestNG. También son más flexibles en términos de ejecución de pruebas, dado que TestNG tiene dependencia de prueba, agrupación y ordenación.

JUnit todavía requiere que ciertos métodos antes/después sean estáticos, lo que limita lo que puede hacer antes de ejecutar las pruebas, TestNG nunca tiene este problema.

TBH, la mayoría de las diferencias entre los dos marcos no significan mucho, a menos que se centre en las pruebas de integración/automatización. JUnit de mi experiencia se construye desde cero para las pruebas unitarias y ahora se está empujando hacia niveles más altos de pruebas, que IMO lo convierte en la herramienta equivocada para el trabajo. TestNG funciona bien en las pruebas unitarias y debido a su robusta provisión de datos y grandes capacidades de ejecución de pruebas, funciona aún mejor en el nivel de prueba de integración/automatización.

Ahora, para lo que creo que es un tema aparte, cómo escribir pruebas bien estructuradas, legibles y mantenibles. La mayor parte de esto estoy seguro de que lo sabes, pero cosas como Patrón de fábrica, Command Pattern y PageObjects (si sus sitios web de prueba) son vitales, es muy es importante tener una capa de abstracción entre lo que su prueba (SUT) y lo que es la prueba real (aserciones de lógica de negocio). Para tener afirmaciones mucho más agradables, puede usar Hamcrest. Hacer uso de la herencia/interfaces javas para reducir la repetición y reforzar la comunalidad.

Casi lo olvido, también use el Patrón de Constructor de datos de prueba , esto junto con la anotación dataprovider de TestNG es muy útil.

Mi opinión sobre lo que hace que TestNG realmente sea mucho más 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.

¿Por qué usamos TestNG en lugar de JUnit?

1. La declaración de @BeforeClass y @AfterClass método tiene que ser estática en JUnit mientras que, hay más flexibilidad en TestNG en la declaración de método, no tiene estas restricciones.

2. En TestNG, podemos parametrizar pruebas usando 2 maneras . Anotación @Parameter o @ dataProvider.

   I) @Parameter para casos simples, donde se requiere la asignación de valores clave.(los datos se proporcionan a través de xml file)

   Ii) @dataProvider para casos complejos. Usando 2 arreglo dimensional, Puede proporcionar datos.

3. En TestNG, dado que el método @dataProvider no necesita ser estático, podemos usar varios métodos de proveedores de datos en la misma clase de prueba.

4. Pruebas de dependencia: En TestNG, si la prueba inicial falla, entonces todas las pruebas dependientes posteriores se omitirán, no se marcarán como fallidas. Pero JUnit marcó que falló.

5. Agrupación: Single las pruebas pueden pertenecer a varios grupos y luego ejecutarse en diferentes contextos (como pruebas lentas o rápidas). Una característica similar existe en las categorías JUnit, pero carece de las anotaciones de prueba @BeforeGroups / @AfterGroups que permiten inicializar la prueba / derribarla.

6. Paralelismo: Si desea ejecutar la misma prueba en paralelo en varios hilos, TestNG lo tiene cubierto con una anotación simple de usar, mientras que JUnit no ofrece una forma sencilla de hacerlo fuera del cuadro.

7. TestNG @ dataProvider también puede admitir XML para alimentar datos, CSV o incluso archivos de texto sin formato.

8. TestNG le permite declarar dependencias entre pruebas, y omitirlas si la prueba de dependencias no pasó.

@Test (dependsOnMethods = {"dependOnSomething"})

Esta funcionalidad no existe en JUnit

1. Presentación de informes:

Los informes de prueba son generados por el valor predeterminado es una carpeta de salida de prueba que incluye informes HTML con todos los datos de prueba, pasados/fallidos/omitidos, cuánto tiempo se ejecutaron, qué entrada se utilizó y los registros de prueba completos. Además, también exporta todo a un archivo XML que se puede utilizar para construir su propia plantilla de informe.

En el frente JUnit, todos estos datos también están disponibles a través de XML, pero no hay un informe listo para usar y debe confiar en los complementos.

Enlace de recursos:

1. Un Rápido Comparación entre JUnit y TestNG
2. JUnit vs. TestNG: ¿Qué Marco de Pruebas Debe Elegir?

Una buena diferencia se da en este tutorial lado a lado: TestNG Vs JUnit: ¿Cuál es la Diferencia?