Junit avant le cours (non statique)

Question

Existe-t-il des pratiques recommandées pour que Junit exécute une fonction une fois dans un fichier test, et cela ne doit pas non plus être statique.

comme @BeforeClass sur une fonction non statique?

Voici une solution laide:

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

Eh bien c'est quelque chose que je ne veux pas faire, et je cherche une solution intégrée junit.

Answer 1

Une simple déclaration si semble plutôt bien fonctionner:

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

        }
    }

 ...
 

Answer 2

Pour utiliser un constructeur vide est la solution la plus simple. Vous pouvez toujours remplacer le constructeur de la classe.

Mais il n'est pas optimale avec tout l'héritage. C'est pourquoi JUnit 4 utilise les annotations à la place.

Une autre option est de créer un helper dans une usine/util classe et de laisser cette méthode de faire le travail.

Si vous êtes à l'aide de Printemps, vous devriez envisager d'utiliser l' @TestExecutionListenersd'annotation. Quelque chose comme ce test:

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

Le printemps de l' AbstractTestExecutionListener contient par exemple cette méthode vide que vous pouvez modifier:

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

Answer 3

Si vous ne souhaitez pas configurer les initialiseurs statiques pour un temps d'initialisation et ne sont pas spécifiques sur l'utilisation de JUnit, jetez un oeil à TestNG. TestNG prise en charge non-statique, un temps d'initialisation avec une variété d'options de configuration, tous les à l'aide d'annotations.

Dans TestNG, ce serait l'équivalent de:

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

Pour le démontage,

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

Pour le TestNG équivalent de JUnit 4 @Before et @After, vous pouvez utiliser @BeforeMethod et @AfterMethod respectivement.

Answer 4

Une autre option à considérer si l’injection de dépendance (par exemple Spring) est @PostConstruct . Cela garantira que l'injection de dépendance est complète, ce qui ne serait pas le cas chez un constructeur:

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

Answer 5

Je n'ai jamais essayé, mais vous pouvez peut-être créer un constructeur sans argument et appeler votre fonction à partir de là?