@BeforeClass y herencia - orden de ejecución

Tengo una clase base abstracta, que uso como base para mis pruebas unitarias (TestNG 5.10). En esta clase, inicializo todo el entorno para mis pruebas, configurando mapeos de base de datos, etc. Esta clase abstracta tiene un método con una @BeforeClassanotación que hace la inicialización.

A continuación, extiendo esa clase con clases específicas en las que tengo @Testmétodos y también @BeforeClassmétodos. Estos métodos realizan la inicialización del entorno específica de la clase (por ejemplo, colocan algunos registros en la base de datos).

¿Cómo puedo hacer cumplir un orden específico de los @BeforeClassmétodos anotados? Necesito que los de la clase base abstracta se ejecuten antes que los de la clase extensible.

Ejemplo:

abstract class A {
    @BeforeClass
    doInitialization() {...}
}

class B extends A {
    @BeforeClass
    doSpecificInitialization() {...}

    @Test
    doTests() {...}
}

Orden esperada:

A.doInitialization
B.doSpecificInitialization
B.doTests

Orden real:

B.doSpecificInitialization // <- crashes, as the base init is missing
(A.doInitialization        // <---not executed
 B.doTests)                // <-/

No pongas @BeforeClassla abstractclase. Llámelo de cada subclase.

abstract class A {
    void doInitialization() {}
}

class B extends A {
    @BeforeClass
    void doSpecificInitialization() {
        super.doInitialization();
    }

    @Test
    void doTests() {}
}

Parece que TestNG lo ha hecho @BeforeClass(dependsOnMethods={"doInitialization"}), pruébalo.

editar: La respuesta a continuación es para JUnit , pero la dejaré aquí de todos modos, porque podría ser útil.

Según la API de JUnit : "Los métodos @BeforeClass de superclases se ejecutarán antes que los de la clase actual".

Probé esto y parece funcionar para mí.

Sin embargo, como @Odys menciona a continuación, para JUnit debe tener los dos métodos nombrados de manera diferente, aunque de lo contrario, solo se ejecutará el método de subclase porque el padre será sombreado.

He añadido publica la clase abstracta y TestNG (6.0.1) ejecuta el doInitialization () antes doTests. TestNG no se ejecuta doInitialization()si elimino publicde la clase A.

public abstract class A {
 @BeforeClass
 doInitialization() {...}
}

class B extends A {    
 @Test
 doTests() {...}
}

Acabo de probar su ejemplo con 5.11 y obtengo el @BeforeClass de la clase base invocado primero.

¿Puedes publicar tu archivo testng.xml? Tal vez esté especificando tanto A como B allí, mientras que solo B es necesario.

No dude en hacer un seguimiento de la lista de correo de testng-users y podremos analizar más de cerca su problema.

- Cedric

Acabo de pasar por esto y encontré una forma más de lograrlo. Solo use alwaysRunen @BeforeClasso @BeforeMethoden la clase abstracta, funciona como es de esperar.

public class AbstractTestClass {
    @BeforeClass(alwaysRun = true)
    public void generalBeforeClass() {
        // do stuff
        specificBeforeClass();
    }
}

Cuando ejecuto desde: JUnitCore.runClasses (TestClass.class); Ejecutará el padre correctamente, antes que el hijo (no necesita super.SetUpBeforeClass (); ) Si lo ejecuta desde Eclipse: por alguna razón, no puede ejecutar la clase base. La solución alternativa : Llame explícitamente a la clase base: ( BaseTest.setUpBeforeClass (); ) Es posible que desee tener una marca en la clase base en caso de que la ejecute desde una aplicación, para determinar si ya está configurada o no. Por lo tanto, solo se ejecuta una vez si lo ejecuta a través de ambos métodos posibles (como desde eclipse para pruebas personales y a través de ANT para una versión de compilación).

Esto parece ser un error con Eclipse, o al menos resultados inesperados.

Para JUnit : Como ha mencionado @fortega: Según la api de JUnit: "Los métodos @BeforeClass de superclases se ejecutarán antes que los de la clase actual".

Pero tenga cuidado de no nombrar ambos métodos con el mismo nombre . Dado que en este caso el método principal estará oculto por el padre secundario. Fuente .

¿Qué tal si tu método @BeforeClass llama a un método específicoBeforeClass () vacío que puede o no ser sobrescrito por subclases como este?

public class AbstractTestClass {
  @BeforeClass
  public void generalBeforeClass() {
    // do stuff
    specificBeforeClass();
  }

  protected void specificBeforeClass() {}
}

public class SpecificTest {
  @Override
  protected void specificBeforeClass() {
    // Do specific stuff
  }

  // Tests
}

dependsOnMethod puede ser usado.

por ejemplo, en el caso de Spring ( AbstractTestNGSpringContextTests)

@BeforeClass(alwaysRun = true, dependsOnMethods = "springTestContextPrepareTestInstance")

Verifique su declaración de importación. Debería ser

import org.testng.annotations.BeforeClass;

no

import org.junit.BeforeClass;

Esto funciona para mí

abstract class A {
    @BeforeClass
    doInitialization() {...}
}

class B extends A {
    @Override
    @BeforeClass
    doInitialization() { 

       //do class specific init

    }   

    @Test
    doTests() {...}
}

¿Por qué no intentas crear un método abstracto doSpecialInit () en tu superclase, llamado desde tu método anotado BeforeClass en la superclase?

Entonces, los desarrolladores que heredan su clase se ven obligados a implementar este método.

Aquí hay otra solución sencilla.

Mi situación particular es que necesito inyectar servicios simulados de "BeforeClass" en la subclase antes de que se ejecute "BeforeClass" en la superclase.

Para hacer esto, simplemente use a @ClassRuleen la subclase.

Por ejemplo:

@ClassRule
public static ExternalResource mocksInjector = new ExternalResource() {
    @Override
    protected void before() {
        // inject my mock services here
        // Note: this is executed before the parent class @BeforeClass
    }
};

Espero que esto ayude. Esto puede ejecutar de forma eficaz la configuración estática en orden "inverso".

Hoy me he enfrentado a un problema similar, la única diferencia era que una clase base no era abstracta

Este es mi caso

public class A {
    @BeforeClass
    private void doInitialization() {...}
}

public class B extends A {
    @BeforeClass
    private void doSpecificInitialization() {...}

    @Test
    public void doTests() {...}
}

Ocurrió que un @BeforeClassmétodo de la clase A nunca se ejecutó.

• A.doInitialization () -> ESTO NUNCA FUE EJECUTADO silenciosamente
• B.doSpecificInitialization ()
• B.doTests ()

Jugando con modificadores de privacidad, encontré que TestNG no ejecutará un @BeforeClassmétodo anotado de una clase heredada si un método no es visible desde un heredero de clase

Entonces esto funcionará:

public class A {
    @BeforeClass
    private void doInitialization() {...}
}

public class B extends A {
    @BeforeClass
    //Here a privacy modifier matters -> please make sure your method is public or protected so it will be visible for ancestors
    protected void doSpecificInitialization() {...}

    @Test
    public void doTests() {...}
}

Como resultado, sucede lo siguiente:

• A.doInitialization ()
• B.doSpecificInitialization ()
• B.doTests ()

En mi caso (JUnit) tengo los mismos métodos llamados setup () en la clase base y la clase derivada. En este caso, solo se llama al método de la clase derivada, y lo hago llamar al método de la clase base.

Una forma mejor y más limpia de lograr esto usando la herencia puede ser la siguiente:

abstract class A {

    @BeforeClass
    void doInitialization() {}
}

class B extends A {

    @Override
    @BeforeClass
    void doInitialization() {
        super.doInitialization();
    }

    @Test
    void doTests() {}
}