¿Puedo especificar un grupo de clase completa en un caso de prueba TestNG?

Question

Tengo una clase base que representa una prueba de base de datos en TestNG, y quiero especificar que todas las clases que se extienden desde esta clase son de un grupo "db-test", sin embargo, he encontrado que esto no parece posible. He tratado de la anotación @test:

@Test(groups = { "db-test" }) 
public class DBTestBase { 
} 

Sin embargo, esto no funciona debido a la anotación @test tratará de hacer un montón de métodos en pruebas y advertencias/errores pop-up en Eclipse cuando las pruebas son correr.

así que traté de desactivación de la prueba, por lo que al menos se asignan los grupos:

@Test(enabled = false, groups = { "db-test" }) 
public class DBTestBase { 
} 

pero entonces cualquier @BeforeTest (y otras anotaciones similares) también consigue discapacitados ... que por supuesto no es lo que querer.

Me gustaría alguna manera de anotar una clase como perteneciente a un tipo particular de grupo, pero no parece ser posible en TestNG. ¿Alguien tiene alguna otra idea?

Answer 1

La respuesta es a través de una costumbre org.testng.IMethodSelector:

Its includeMethod() puede excluir cualquier método que deseemos, como un método público no anotado.

Sin embargo, para registrar un encargo de Java MethodSelector, debe agregarlo a la instancia PruebaXml administrado por cualquier TestRunner, lo que significa que necesita su propio encargo TestRunner.

Pero, para construir un TestRunner personalizada, es necesario registrar una TestRunnerFactory, a través de la opción -testrunfactory.

PERO NUNCA -testrunfactory que se toma en cuenta por TestNG clase ... lo que es necesario también definir una clase personalizada TestNG: Método

• con el fin de anular la configuración (Mapa),
• , porque se puede ajustar la TestRunnerFactory
• TestRunnerFactory que se puede construir un TestRunner encargo,
• TestRunner que se establece en la instancia PruebaXml un XMLMethodSelector encargo
• XMLMethodSelector que creará un IMethodSelector personalizado
• IMethodSelector que excluirá los métodos TestNG que elija.

Ok ... es una pesadilla. Pero también es un desafío de código, por lo que debe ser un poco desafiante;)

Todo el código está disponible en DZone snippets.

Como es habitual para un desafío código:

• una clase de Java (y algunas clases bastantes interiores)
• copiar y pegar la clase en un directorio 'fuente/test' (ya que el paquete es " prueba ')
• ejecutarlo (no hay argumentos necesarios)

---

actualización de Mike Stone:

Voy a aceptar esto porque suena bastante parecido a lo que terminé haciendo, pero pensé que agregaría lo que hice también.

Básicamente, creé una anotación de grupos que se comporta como la propiedad de grupos de la prueba (y otras) anotaciones.

Luego, creé un GroupAnnotationTransformer, que utiliza IAnnotationTransformer para ver todas las pruebas y clases de prueba que se están definiendo, luego modifica la prueba para agregar los grupos, que funciona perfectamente con la exclusión e inclusión de grupos.

Modifique la construcción para usar el nuevo transformador de anotación, ¡y todo funciona perfectamente!

Bueno ... la única advertencia es que no agrega los grupos a los métodos que no son de prueba ... porque en el momento en que hice esto, había otro transformador de anotación que te permite transformar CUALQUIER COSA, pero de alguna manera no estaba incluido en el TestNG que estaba usando por alguna razón ... así que es una buena idea hacer sus métodos antes/después anotados para alwaysRun = true ... que es suficiente para mí.

El resultado final es que puedo hacer:

@Groups({ "myGroup1", "myGroup2"}) 
public class MyTestCase { 
    @Test 
    @Groups("aMethodLevelGroup") 
    public void myTest() { 
    } 
} 

y he hecho el trabajo transformador con la subclasificación y todo.

Answer 2

No estoy seguro de cómo funciona la herencia de anotación para TestNG, pero este artículo puede ser de alguna utilidad. http://beust.com/weblog/archives/000170.html.

En realidad, esto puede ayudar mejor http://testng.org/doc/documentation-main.html#annotations, consulte inheritGroups.

Answer 3

TestNG ejecutará todos los métodos públicos de una clase con una anotación @Test. Tal vez podría cambiar los métodos que no desea que TestNG se ejecute como no pública

Answer 4

Puede especificar la anotación @Test al nivel de método que permite la máxima flexibilidad.

public class DBTestBase { 

    @BeforeTest(groups = "db-test") 
    public void beforeTest() { 
     System.out.println("Running before test"); 
    } 

    public void method1() { 
     Assert.fail(); // this does not run. It does not belong to 'db-test' group. 
    } 

    @Test(groups = "db-test") 
    public void testMethod1() { 
     Assert.assertTrue(true); 
    } 
} 

Esto funciona para usted o me falta algo de su pregunta.

Answer 5

parecería a mí como el siguiente código reto (post wiki de la comunidad):

cómo ser capaz de ejecutar todos los métodos de prueba de clase extendida del grupo 'aGlobalGroup' sin:

• especificando el grupo 'aGlobalGroup' en la clase extendida en sí?
• probando métodos públicos no anotados de clase extendida?

La primera respuesta es fácil:
añadir un TestNG clase (grupos = { "aGlobalGroup"}) en el nivel Clase base

Ese grupo se aplicará a todos los métodos públicos, tanto de la clase Base y clase extendida.

PERO: incluso los métodos públicos sin prueba (sin anotación TestNG) se incluirán en ese grupo.

DESAFÍO: evite incluir aquellos métodos que no sean TestNG.

@Test(groups = { "aGlobalGroup" }) 
public class Base { 

    /** 
    * 
    */ 
    @BeforeClass 
    public final void setUp() { 
      System.out.println("Base class: @BeforeClass"); 
    } 


    /** 
    * Test not part a 'aGlobalGroup', but still included in that group due to the class annotation. <br /> 
    * Will be executed even if the TestNG class tested is a sub-class. 
    */ 
    @Test(groups = { "aLocalGroup" }) 
    public final void aFastTest() { 
     System.out.println("Base class: Fast test"); 
    } 

    /** 
    * Test not part a 'aGlobalGroup', but still included in that group due to the class annotation. <br /> 
    * Will be executed even if the TestNG class tested is a sub-class. 
    */ 
    @Test(groups = { "aLocalGroup" }) 
    public final void aSlowTest() { 
     System.out.println("Base class: Slow test"); 
     //throw new IllegalArgumentException("oups"); 
    } 

    /** 
     * Should not be executed. <br /> 
     * Yet the global annotation Test on the class would include it in the TestNG methods... 
    */ 
    public final void notATest() { 
     System.out.println("Base class: NOT a test"); 
    } 

    /** 
    * SubClass of a TestNG class. Some of its methods are TestNG methods, other are not. <br /> 
    * The goal is to check if a group specify in the super-class will include methods of this class. <br /> 
    * And to avoid including too much methods, such as public methods not intended to be TestNG methods. 
    * @author <a href="http://stackoverflow.com/users/6309/vonc">VonC</a> 
    */ 
    public static class Extended extends Base 
    { 
     /** 
     * Test not part a 'aGlobalGroup', but still included in that group due to the super-class annotation. <br /> 
     * Will be executed even if the TestNG class tested is a sub-class. 
     */ 
     @Test 
     public final void anExtendedTest() { 
      System.out.println("Extended class: An Extended test"); 
     } 

     /** 
     * Should not be executed. <br /> 
     * Yet the global annotation Test on the class would include it in the TestNG methods... 
     */ 
     public final void notAnExtendedTest() { 
      System.out.println("Extended class: NOT an Extended test"); 
     } 
    }