¿Puedo especificar un grupo para toda la clase 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, descubrí que esto no parece posible.Probé la anotación @Test:

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

Sin embargo, esto no funciona porque la anotación @Test intentará convertir un montón de métodos en pruebas y aparecerán advertencias/errores en eclipse cuando se ejecuten las pruebas.

Entonces intenté deshabilitar la prueba, para que al menos se asignen los grupos:

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

pero luego cualquier @BeforeTest (y otras anotaciones similares) TAMBIÉN se desactivan...que por supuesto no es lo que quiero.

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

Answer 1

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

Es incluirmétodo() Podemos excluir cualquier método que queramos, como un método público no anotado.

Sin embargo, para registrar una costumbre Java MethodSelector, debes agregarlo al Prueba XML instancia administrada por cualquier TestRunner, lo que significa que necesita su propia corredor de pruebas personalizado.

Pero, para crear un TestRunner personalizado, debe registrar un TestRunnerFábrica, a través de -testrunfactory opción.

PERO eso -testrunfactory NUNCA es tenido en cuenta por PruebaNG clase...por lo que también necesitas definir una clase TestNG personalizada:

• Para anular el método configure(Map),
• para que puedas configurar TestRunnerFactory
• TestRunnerFactory que le creará un TestRunner personalizado,
• TestRunner que establecerá en la instancia XMLTest un XMLMethodSelector personalizado
• XMLMethodSelector que construirá un IMethodSelector personalizado
• ¡IMethodSelector que excluirá cualquier método TestNG de su elección!

De acuerdo...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 Fragmentos de zona D.

Como es habitual en un desafío de código:

• una clase java (y bastantes clases internas)
• copiar y pegar la clase en un directorio 'fuente/prueba' (ya que el paquete es 'prueba')
• ejecútelo (no se necesitan argumentos)

---

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 las anotaciones de Prueba (y otras).

Luego, creé un GroupsAnnotationTransformer, que usa IAnnotationTransformer para observar todas las pruebas y clases de prueba que se están definiendo, luego modifico la prueba para agregar los grupos, lo que funciona perfectamente con la exclusión e inclusión de grupos.

Modifique la compilación para usar el nuevo transformador de anotación y ¡todo funcionará perfectamente!

Bien...la única advertencia es que no agrega los grupos a métodos que no sean 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...por lo que es una buena idea hacer que los métodos anotados antes/después sean siempreRun=true...lo cual es suficiente para mí.

El resultado final es que puedo hacer:

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

E hice que el transformador funcionara con subclases y todo.

Answer 2

TestNG ejecutará todos los métodos públicos de una clase con una anotación @Test.Tal vez podrías cambiar los métodos que no deseas que ejecute TestNG para que no sean públicos.

Answer 3

Me pareceria lo siguiente desafío de código (publicación wiki de la comunidad):

Cómo poder ejecutar todos los métodos de prueba de la clase Extendida del grupo 'aGlobalGroup' sin:

• ¿especificando el grupo 'aGlobalGroup' en la propia clase extendida?
• ¿Probar métodos públicos no anotados de la clase extendida?

La primera respuesta es fácil:
agregue una clase TestNG(groups = { "aGlobalGroup" }) en el nivel de clase base

Ese grupo se aplicará a todos los métodos públicos tanto de la clase Base como de la clase Extendida.

PERO:incluso los métodos públicos que no sean de prueba (sin anotaciones 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");
        }
    }

Answer 4

No estoy seguro de cómo funciona la herencia de anotaciones para TestNG, pero esto artículo puede ser de alguna utilidad.

En realidad, esto puede ayudar mejor, mira heredarGrupos.

Answer 5

Puede especificar la anotación @Test a 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 en su pregunta?