java - unitaria - selenium

¿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 probado la anotación @Test:

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

Sin embargo, esto no funciona porque la anotación @Test intentará convertir varios métodos en pruebas, y las advertencias / errores aparecen en eclipse cuando se ejecutan las pruebas.

Así que intenté desactivar la prueba, por lo que al menos los grupos están asignados:

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

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

Me gustaría alguna manera 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

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 a mejorar http://testng.org/doc/documentation-main.html#annotations , consulte inheritGroups.

Answer 2

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 ejecute para ser no público

Answer 3

Puede especificar la anotación @Test en el 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 4

Me parece que es el 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 clase extendida en sí misma?
• probando métodos públicos no anotados de 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 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://.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 5

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

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

Sin embargo, para registrar un Java MethodSelector personalizado, debe agregarlo a la instancia XMLTest administrada por cualquier TestRunner, lo que significa que necesita su propio TestRunner personalizado .

Sin embargo, para crear un TestRunner personalizado, debe registrar un TestRunnerFactory a través de la opción -testrunfactory .

PERO esa clase de daño nunca se tiene en cuenta en la clase TestNG ... por lo que también necesita definir una clase TestNG personalizada:

• para anular el método de configuración (Mapa),
• para que pueda configurar TestRunnerFactory
• TestRunnerFactory que te construirá un TestRunner personalizado,
• TestRunner que establecerá en la instancia de XMLTest un XMLMethodSelector personalizado
• XMLMethodSelector que construirá un IMethodSelector personalizado
• ¡IMethodSelector que excluirá cualquier método TestNG de su elección!

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 los fragmentos de DZone .

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

• una clase de Java (y bastantes clases internas)
• copiar y pegar la clase en un directorio ''fuente / prueba'' (ya que el paquete es ''prueba'')
• ejecutarlo (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 los grupos de la Prueba (y otras) anotaciones.

Luego, creé un GroupAnnotationTransformer, que usa IAnnotationTransformer para ver todas las pruebas y clases de prueba que se están definiendo, luego modifica la prueba para agregar los grupos, lo 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 anotados antes / después 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 hice que el transformador funcionara con subclases y todo.