¿Puedo evitar ejecutar pruebas junit dos veces en eclipse cuando uso TestSuite?

Question

Necesito hacer alguna inicialización por suite (iniciando un servidor web). Está funcionando bien, excepto que cuando ejecuto todas las pruebas en mi proyecto en eclipse, mis pruebas se ejecutan dos veces. Mi banco de pruebas se ve un poco como esto:

@RunWith(Suite.class) 
@Suite.SuiteClasses({ 
    SubtestOne.class, 
    SubtestTwo.class 
}) 
public class TestSuite 
{ 
    [...] 
} 

public class SubtestOne 
{ 
    @Test public void testOne() { [...] } 
} 

public class SubtestTwo 
{ 
    @Test public void testTwo() { [...] } 
} 

Cuando corro todas las pruebas en el proyecto en Eclipse Esto hace que el plug-in junit para ejecutar las pruebas en dos ocasiones como esta:

• SubtestOne
• SubtestTwo
• TestSuite
  • SubtestOne
  • SubtestTwo

¿Es posible hacer "ejecutar todas las pruebas en el proyecto" no ejecutar las sub-pruebas dos veces? Quiero que mis subpruebas solo se ejecuten como parte de la suite.

Answer 1

No, la clase de prueba siempre se iniciará directamente y luego a través del "enlace" en el paquete. Esto es como se esperaba

Una solución alternativa podría establecerse en la configuración de ejecución para ejecutar solo pruebas del paquete que contiene sus suites. Abra la configuración de ejecución y seleccione Run all tests in the selected project, package or source folder, luego haga clic en Search... y seleccione el paquete.

Answer 2

Tengo una idea para ti. En realidad, no desea ejecutar estos casos de prueba como casos de prueba independientes. Puedes hacer lo siguiente.

Marcar los casos de prueba con la anotación @RunWith(DoNothingRunner.class)

Implment DoNothingRunner de la siguiente manera:

public class DoNothingRunner extends Runner { 
    public Description getDescription() { 
       return "do nothing"; 
     } 
    public void run(RunNotifier notifier) { 
      // indeed do nothing 
     } 
} 

no he probado personalmente, pero espero que esto va a funcionar.

Answer 3

¿Necesita el paquete en primer lugar? dependiendo de cuándo haga clic para ejecutar todo (clase, paquete o src/prueba/java), se ejecutarán todas las pruebas subyacentes. Entonces, ¿de qué sirve tener una suite?

Answer 4

Me doy cuenta de que esto se ha pedido hace más de 5 años, pero como mucha gente votó la pregunta, pensé que todavía encontraría una solución. Salta directamente al final si solo quieres la solución; lea el texto completo si también quiere entenderlo ;-)

En primer lugar, es posible garantizar que una determinada clase de prueba JUnit solo se ejecute dentro de un banco de pruebas. Además, es irrelevante si desea ejecutar ese conjunto de pruebas dentro de Eclipse (como se le preguntó aquí) o cualquier otra herramienta o entorno; esto es realmente un problema puro de JUnit en su mayor parte.

Antes de esbozar la solución, podría ser una buena idea volver a ver cuál es el problema exacto aquí. Todas las pruebas de JUnit deben estar visibles y ser instanciadas para ser recogidas por el framework JUnit y sus diferentes corredores. Esto también se aplica a los conjuntos de pruebas y las pruebas individuales que forman parte de un conjunto de pruebas. Como consecuencia, si JUnit recupera el banco de pruebas, también seleccionará las pruebas individuales, y todas las pruebas del conjunto se ejecutarán dos veces, una por separado y otra como parte del conjunto.

Por lo tanto, el truco, si se quiere, es evitar que JUnit recoja las pruebas individuales mientras aún puede instanciarlas y ejecutarlas como parte de la suite.

Una cosa que me viene a la mente es hacer que las clases de prueba tengan clases internas estáticas anidadas dentro del conjunto de pruebas. Sin embargo, las clases anidadas aún deben ser públicas (de lo contrario, tampoco se pueden ejecutar en el conjunto), y si son clases públicas, también se recogerán individualmente, a pesar de estar anidadas dentro de la clase pública de la suite. Sin embargo, JUnit no intentará ejecutar clases de prueba que no se consideren visibles. Entonces, anidar las clases de prueba dentro de una clase no pública sería presumiblemente suficiente para ocultarlas, pero no podemos hacer que la clase suite sea no pública porque entonces JUnit no la ejecutaría. Lo que podemos hacer, sin embargo, es a anidar las pruebas individuales dentro de otra clase no pública que está anidado dentro del conjunto de pruebas, lo que nos lleva a la solución de este enigma:

import org.junit.Test; 
import org.junit.runner.RunWith; 
import org.junit.runners.Suite; 
import org.junit.runners.Suite.SuiteClasses; 

@RunWith(Suite.class) 
@SuiteClasses({AllTests.InSuiteOnly.Test1.class, AllTests.InSuiteOnly.Test2.class}) 
public class AllTests 
{ 
    static class InSuiteOnly 
    { 
     public static class Test1 
     { 
      @Test 
      public void test1() 
      { 
       //... 
      } 
     } 

     public static class Test2 
     { 
      @Test 
      public void test2() 
      { 
       //... 
      } 
     } 
    } 
} 

Mucha gente probablemente se opondrán a todas las pruebas que necesitan estar dentro de un único archivo fuente ahora. ¿Qué sucede si deseo mantener clases de prueba JUnit separadas que no se ejecutan por sí mismas pero que aún se ejecutan dentro del conjunto de pruebas? Una solución simple es hacer que las clases de prueba individuales sean abstractas (público/no público no importa) para que JUnit no las ejecute, y dentro del conjunto de pruebas simplemente usamos subclases concretas de las clases de prueba abstractas originales:

import org.junit.Test; 
import org.junit.runner.RunWith; 
import org.junit.runners.Suite; 
import org.junit.runners.Suite.SuiteClasses; 

@RunWith(Suite.class) 
@SuiteClasses({AllTests.InSuiteOnly.SuiteTest1.class, AllTests.InSuiteOnly.SuiteTest2.class}) 
public class AllTests 
{ 
    static class InSuiteOnly 
    { 
     public static class SuiteTest1 extends Test1 {} 
     public static class SuiteTest2 extends Test2 {} 
    } 
} 

abstract class Test1 
{ 
    @Test 
    public void test1() 
    { 
     //... 
    } 
} 

abstract class Test2 
{ 
    @Test 
    public void test2() 
    { 
     //... 
    } 
} 

Este esquema funciona con Maven, Eclipse y todos los demás entornos que aprovechan directamente los corredores de JUnit o implementan sus propios corredores que siguen de cerca el comportamiento y la semántica originales de JUnit.