@BeforeClass ed ereditarietà - ordine di esecuzione

Question

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

Successivamente, estendo tale classe con classi specifiche in cui dispongo di metodi @Test e anche di metodi @BeforeClass. Questi metodi eseguono l'inizializzazione specifica della classe dell'ambiente (ad esempio, inseriscono alcuni record nel database).

Come è possibile applicare un ordine specifico dei metodi annotati @BeforeClass? Ho bisogno che quelli della classe base astratta siano eseguiti prima di quelli della classe che si estende.

Esempio: ordine

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

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

    @Test 
    doTests() {...} 
} 

atteso:

A.doInitialization 
B.doSpecificInitialization 
B.doTests 

ordine attuale:

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

Answer 1

non mettere il @BeforeClass sulla classe abstract. Chiamalo da ogni sottoclasse.

abstract class A { 
    void doInitialization() {} 
} 

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

    @Test 
    void doTests() {} 
} 

Sembra come TestNG ha @BeforeClass(dependsOnMethods={"doInitialization"}) - fare un tentativo.

Answer 2

edit: risposta sotto è per JUnit, ma mi lascerà qui in ogni caso, perché potrebbe essere utile.

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

Ho provato questo, e sembra funzionare per me.

Tuttavia, come @Odys cita di seguito, per JUnit è necessario avere le due metodi chiamati in modo diverso anche se, come fare altrimenti comporterà solo il metodo della sottoclasse in esecuzione perché il genitore sarà oscurato.

Answer 3

Ho appena provato il tuo esempio con 5.11 e ottengo il @BeforeClass della classe base invocato per primo.

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

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

- Cedric

Answer 4

ne dite di avere il tuo metodo di @BeforeClass chiamare un metodo vuoto specificBeforeClass(), che può o non può essere sovrascritto da classi secondarie 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 
} 

Answer 5

ho aggiunto public a la classe astratta e TestNG (6.0.1) hanno eseguito la funzione doInitialization() prima di doTests.TestNG non esegue doInitialization() se tolgo public dalla classe A.

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

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

Answer 6

Quando eseguo da: JUnitCore.runClasses (TestClass.class); si eseguirà il genitore correttamente, prima che il bambino (Non è necessario super.SetUpBeforeClass();) Se lo si esegue da Eclipse: Per qualche ragione non riesce a eseguire la classe di base. Il lavoro in giro: Chiamare la classe base in modo esplicito: (BaseTest.setUpBeforeClass();) Si consiglia di avere un flag nella classe base nel caso lo si esegua da un'applicazione, per determinare se è già impostato o no. Quindi viene eseguito una volta sola se lo si esegue tramite entrambi i metodi possibili (ad esempio da eclipse per i test personali e tramite ANT per una versione di build).

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

Answer 7

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

Answer 8

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

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

Answer 9

Ho appena passato questo e ho trovato un altro modo per raggiungere questo obiettivo. Basta usare alwaysRun su @BeforeClass o @BeforeMethod nella classe astratta, funziona come ci si aspetterebbe.

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

Answer 10

dependsOnMethod può essere utilizzato.

ad es. in caso di molla (AbstractTestNGSpringContextTests)

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

Answer 11

Un modo migliore e più pulito per ottenere ciò utilizzando ereditarietà può essere come segue -

abstract class A { 

    @BeforeClass 
    void doInitialization() {} 
} 

class B extends A { 

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

    @Test 
    void doTests() {} 
} 

Answer 12

Per JUnit: Come @fortega ha accennato: Secondo to the JUnit api: "I metodi @BeforeClass delle superclassi verranno eseguiti prima di quelli della classe corrente."

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

Answer 13

C'è un'altra soluzione facile qui.

La mia situazione particolare è che ho bisogno di iniettare servizi di simulazione da "BeforeClass" nella sottoclasse prima dell'esecuzione di "BeforeClass" nella superclasse.

Per fare ciò, utilizzare semplicemente un @ClassRule nella sottoclasse.

Ad 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 questo aiuta. Questo può effettivamente eseguire l'installazione statica in ordine "inverso".

Answer 14

Controlla la tua dichiarazione di importazione. Dovrebbe essere

import org.testng.annotations.BeforeClass;

non

import org.junit.BeforeClass;