@BeforeClass ed ereditarietà - ordine di esecuzione

Ho una classe base astratta, che uso come base per i miei unit test (TestNG 5.10). In questa classe, inizializzo l'intero ambiente per i miei test, configurando i mapping del database, ecc. Questa classe astratta ha un metodo con @BeforeClassun'annotazione che esegue l'inizializzazione.

Successivamente, estendo quella classe con classi specifiche in cui ho @Testmetodi e anche @BeforeClassmetodi. Questi metodi eseguono l'inizializzazione dell'ambiente specifica della classe (ad esempio, inseriscono alcuni record nel database).

Come posso applicare un ordine specifico dei @BeforeClassmetodi annotati? Ho bisogno che quelli della classe base astratta vengano eseguiti prima di quelli della classe extending.

Esempio:

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

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

    @Test
    doTests() {...}
}

Ordine previsto:

A.doInitialization
B.doSpecificInitialization
B.doTests

Ordine effettivo:

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

Non mettere @BeforeClassin abstractclasse. Chiamalo da ogni sottoclasse.

abstract class A {
    void doInitialization() {}
}

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

    @Test
    void doTests() {}
}

Sembra che TestNG abbia @BeforeClass(dependsOnMethods={"doInitialization"})- provalo.

modifica: la risposta di seguito è per JUnit , ma la lascerò comunque qui, perché potrebbe essere utile.

Secondo l' api JUnit : "I metodi @BeforeClass delle superclassi verranno eseguiti prima di quelli della classe corrente."

L'ho provato e sembra funzionare per me.

Tuttavia, come menzionato di seguito da @Odys, per JUnit è necessario che i due metodi siano denominati in modo diverso, anche se in caso contrario verrà eseguito solo il metodo della sottoclasse perché il genitore sarà ombreggiato.

Ho aggiunto publicalla classe abstract e TestNG (6.0.1) ha eseguito prima doInitialization () doTests. TestNG non viene eseguito doInitialization()se rimuovo publicdalla classe A.

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

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

Ho appena provato il tuo esempio con 5.11 e ottengo la @BeforeClass della classe base invocata per prima.

Puoi pubblicare il tuo file testng.xml? Forse stai specificando sia A che B lì, mentre solo B è necessario.

Sentiti libero di seguire la mailing list testng-users e possiamo dare un'occhiata più da vicino al tuo problema.

- Cedric

Ho appena passato questo e ho trovato un altro modo per ottenerlo. Basta usare alwaysRunsu @BeforeClasso @BeforeMethodnella classe astratta, funziona come ti aspetteresti.

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

Quando eseguo da: JUnitCore.runClasses (TestClass.class); Eseguirà correttamente il genitore, prima del figlio (non hai bisogno di super.SetUpBeforeClass (); ) Se lo esegui da Eclipse: Per qualche motivo non riesce a eseguire la classe base. Soluzione : chiamare la classe di base in modo esplicito: ( BaseTest.setUpBeforeClass (); ) Potresti voler avere un flag nella classe di base nel caso in cui la esegui da un'applicazione, per determinare se è già impostata o meno. Quindi viene eseguito solo una volta se lo si esegue tramite entrambi i metodi possibili (ad esempio da eclipse per test personali e tramite ANT per una versione build).

Questo sembra essere un bug con Eclipse, o almeno risultati inaspettati ..

Per JUnit : Come ha menzionato @fortega: Secondo l'API JUnit: "I metodi @BeforeClass delle superclassi verranno eseguiti prima di quelli della classe corrente."

Ma attenzione a non nominare entrambi i metodi con lo stesso nome . Poiché in questo caso il metodo genitore verrà nascosto dal genitore figlio. Fonte .

Che ne dici di avere il tuo metodo @BeforeClass chiamare un metodo specificBeforeClass () vuoto che può o non può essere sovrascritto da sottoclassi in questo modo:

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 può essere utilizzato.

ad es. in caso di primavera ( AbstractTestNGSpringContextTests)

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

Controlla la tua dichiarazione di importazione. Dovrebbe essere

import org.testng.annotations.BeforeClass;

non

import org.junit.BeforeClass;

Questo funziona per me -

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

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

       //do class specific init

    }   

    @Test
    doTests() {...}
}

Perché non provi a creare un metodo astratto doSpecialInit () nella tua super classe, chiamato dal tuo metodo annotato BeforeClass in superclasse.

Quindi gli sviluppatori che ereditano la tua classe sono costretti a implementare questo metodo.

C'è un'altra semplice soluzione qui.

La mia situazione particolare è che ho bisogno di iniettare servizi fittizi da "BeforeClass" nella sottoclasse prima che "BeforeClass" nella superclasse venga eseguito.

Per fare ciò, usa semplicemente a @ClassRulenella sottoclasse.

Per esempio:

@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
    }
};

Spero che aiuti. Questo può eseguire efficacemente la configurazione statica in ordine "inverso".

Oggi ho affrontato un problema simile, l'unica differenza era che una classe Base non era astratta

Ecco il mio caso

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

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

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

Si è verificato che un @BeforeClassmetodo della classe A non è mai stato eseguito.

• A.doInitialization () -> QUESTO NON È STATO MAI ESEGUITO silenziosamente
• B.doSpecificInitialization ()
• B.doTests ()

Giocando con i modificatori della privacy ho scoperto che TestNG non eseguirà un @BeforeClassmetodo annotato dalla classe ereditata se un metodo non è visibile da un ereditatore di classe

Quindi questo funzionerà:

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() {...}
}

Di conseguenza accade quanto segue:

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

Nel mio caso (JUnit) ho gli stessi metodi chiamati setup () nella classe base e nella classe derivata. In questo caso viene chiamato solo il metodo della classe derivata e io ho chiamato il metodo della classe base.

Un modo migliore e più pulito per ottenere questo risultato utilizzando l'ereditarietà potrebbe essere il seguente:

abstract class A {

    @BeforeClass
    void doInitialization() {}
}

class B extends A {

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

    @Test
    void doTests() {}
}