Junit antes de clase (no estático)

¿Existen mejores prácticas para que Junit ejecute una función una vez en un archivo de prueba, y tampoco debería ser estático?

como @BeforeClassen la función no estática?

Aquí hay una fea solución:

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

Bueno, esto es algo que no quiero hacer y estoy buscando una solución junit integrada.

Si no desea configurar inicializadores estáticos para una inicialización única y no es particular sobre el uso de JUnit, eche un vistazo a TestNG. TestNG admite la inicialización no estática de una sola vez con una variedad de opciones de configuración, todas usando anotaciones.

En TestNG, esto sería equivalente a:

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

Para desmontaje,

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

Para el equivalente TestNG de JUnit 4 @Beforey @After, puede usar @BeforeMethody @AfterMethodrespectivamente.

Una simple declaración if también parece funcionar bastante bien:

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

        }
    }

 ...

Utilizar un constructor vacío es la solución más sencilla. Aún puede anular el constructor en la clase extendida.

Pero no es óptimo con toda la herencia. Es por eso que JUnit 4 usa anotaciones en su lugar.

Otra opción es crear un método auxiliar en una clase factory / util y dejar que ese método haga el trabajo.

Si está usando Spring, debería considerar usar la @TestExecutionListenersanotación. Algo como esta prueba:

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

Spring AbstractTestExecutionListenercontiene, por ejemplo, este método vacío que puede anular:

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

NOTA: NO pase por alto / pase por alto DependencyInjectionTestExecutionListeneral agregar personalizado TestExecutionListeners. Si lo hace, todos los cables automáticos serán null.

Utilice fácilmente @BeforeAllMethods/ @AfterAllMethodsanotaciones para ejecutar un método dentro del contexto de la instancia (no estático), donde estarán disponibles todos los valores inyectados.

Hay una biblioteca de pruebas especial para esto:

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/

La única limitación: funciona solo para las pruebas de Spring .

(Soy el desarrollador de esta biblioteca de pruebas)

Nunca lo intenté, pero tal vez puedas crear un constructor sin argumentos y llamar a tu función desde allí.

El artículo analiza 2 soluciones muy buenas para este problema:

1. junit "limpio" con Runner personalizado (usando la interfaz, pero puede ampliarlo con una anotación personalizada, por ejemplo, @BeforeInstance)
2. Oyentes de ejecución de primavera como lo mencionó Espen antes.

ACTUALIZACIÓN: Consulte el comentario de Cherry sobre por qué la sugerencia a continuación es defectuosa. (Mantengo la respuesta aquí en lugar de eliminarla, ya que el comentario puede proporcionar información útil a otros sobre por qué esto no funciona).

Otra opción que vale la pena considerar si se usa la inyección de dependencia (por ejemplo, Spring) es @PostConstruct. Esto garantizará que la inyección de dependencias esté completa, lo que no sería el caso en un constructor:

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

Solo usa @BeforeClass:

@BeforeClass
public static void init() {
}

No tiene sentido initque no sea estático porque cada prueba se ejecuta en una instancia separada. La instancia que initse ejecuta no coincidirá con la instancia de ninguna prueba.

La única razón por la que puede querer que no sea estático es anularlo en subclases, pero también puede hacerlo con métodos estáticos. Simplemente use el mismo nombre, y solo initse llamará al método de subclase .