Junit prima della lezione (non statico)

Esistono best practice per fare in modo che Junit esegua una funzione una volta in un file di test e non dovrebbe essere statico.

come @BeforeClasssulla funzione non statica?

Ecco una brutta soluzione:

@Before void init(){
    if (init.get() == false){
        init.set(true);
        // do once block
    }
}

beh, questo è qualcosa che non voglio fare e sto cercando una soluzione junit integrata.

Se non vuoi impostare inizializzatori statici per l'inizializzazione una tantum e non sei particolarmente interessato all'uso di JUnit, dai un'occhiata a TestNG. TestNG supporta l'inizializzazione una tantum non statica con una varietà di opzioni di configurazione, tutte utilizzando annotazioni.

In TestNG, questo sarebbe equivalente a:

@org.testng.annotations.BeforeClass
public void setUpOnce() {
   // One time initialization.
}

Per lo smontaggio,

@org.testng.annotations.AfterClass
public void tearDownOnce() {
   // One time tear down.
}

Per l'equivalente TestNG di JUnit 4 @Beforee @After, puoi usare @BeforeMethode @AfterMethodrispettivamente.

Anche una semplice istruzione if sembra funzionare abbastanza bene:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:test-context.xml"})
public class myTest {

    public static boolean dbInit = false;

    @Autowired
    DbUtils dbUtils;

    @Before
    public void setUp(){

        if(!dbInit){

            dbUtils.dropTables();
            dbUtils.createTables();
            dbInit = true;

        }
    }

 ...

Utilizzare un costruttore vuoto è la soluzione più semplice. È ancora possibile sovrascrivere il costruttore nella classe estesa.

Ma non è ottimale con tutta l'eredità. Ecco perché JUnit 4 utilizza invece le annotazioni.

Un'altra opzione è creare un metodo di supporto in una classe factory / util e lasciare che il metodo faccia il lavoro.

Se stai usando Spring, dovresti considerare l'utilizzo @TestExecutionListenersdell'annotazione. Qualcosa di simile a questo test:

@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({CustomTestExecutionListener.class, 
     DependencyInjectionTestExecutionListener.class})
@ContextConfiguration("test-config.xml")
public class DemoTest {

Spring's AbstractTestExecutionListenercontiene ad esempio questo metodo vuoto che puoi sovrascrivere:

public void beforeTestClass(TestContext testContext) throws Exception {
    /* no-op */
}

NOTA: NON trascurare / perdere DependencyInjectionTestExecutionListenerdurante l'aggiunta di personalizzazioni TestExecutionListeners. Se lo fai, tutti i cavi automatici saranno null.

Usa facilmente @BeforeAllMethods/ @AfterAllMethodsannotations per eseguire un metodo all'interno del contesto dell'istanza (non statico), dove saranno disponibili tutti i valori iniettati.

C'è una libreria di test speciale per questo:

https://mvnrepository.com/artifact/org.bitbucket.radistao.test/before-after-spring-test-runner/0.1.0

https://bitbucket.org/radistao/before-after-spring-test-runner/

Unica limitazione: funziona solo per i test di primavera .

(Sono lo sviluppatore di questa libreria di test)

Non ho mai provato, ma forse puoi creare un costruttore senza argomenti e chiamare la tua funzione da lì?

L'articolo discute 2 soluzioni molto belle per questo problema:

1. junit "pulito" con Runner personalizzato (usando l'interfaccia ma potresti estenderlo con un'annotazione personalizzata, ad esempio @BeforeInstance)
2. Ascoltatori di esecuzioni primaverili come menzionato prima da Espen.

AGGIORNAMENTO: Si prega di vedere il commento di Cherry per il motivo per cui il suggerimento di seguito è errato. (Sto mantenendo la risposta qui anziché eliminarla poiché il commento potrebbe fornire informazioni utili ad altri sul motivo per cui non funziona.)

Un'altra opzione da considerare se si utilizza l'inserimento di dipendenze (ad esempio Spring) è @PostConstruct. Ciò garantirà che l'inserimento delle dipendenze sia completo, cosa che non sarebbe il caso in un costruttore:

@PostConstruct
public void init() {
    // One-time initialization...
}

Usa solo @BeforeClass:

@BeforeClass
public static void init() {
}

Non ha senso initessere non statici perché ogni test viene eseguito in un'istanza separata. L'istanza su cui initviene eseguito non corrisponderebbe all'istanza di alcun test.

L'unico motivo per cui potresti volere che non sia statico è sovrascriverlo nelle sottoclassi, ma puoi farlo anche con metodi statici. Basta usare lo stesso nome e initverrà chiamato solo il metodo della sottoclasse .