Transaction d’annulation après @Test

Tout d’abord, j’ai trouvé beaucoup de discussions sur StackOverflow à ce sujet, mais aucune ne m’a vraiment aidé, alors désolé de poser éventuellement une question en double.

J’exécute les tests JUnit en utilisant un test de spring, mon code ressemble à ceci

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {}) public class StudentSystemTest { @Autowired private StudentSystem studentSystem; @Before public void initTest() { // set up the database, create basic structure for testing } @Test public void test1() { } ... } 

Mon problème est que je veux que mes tests n’influencent PAS d’autres tests. Donc, je voudrais créer quelque chose comme rollback pour chaque test. J’ai beaucoup cherché pour cela, mais je n’ai rien trouvé jusqu’à présent. J’utilise Hibernate et MySQL pour cela

Ajoutez @Transactional annotation @Transactional en haut de votre test:

 @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {"testContext.xml"}) @Transactional public class StudentSystemTest { 

Par défaut, Spring lancera une nouvelle transaction entourant votre méthode de test et les @Before / @After , qui @Before @After à la fin. Cela fonctionne par défaut, il suffit d’avoir un gestionnaire de transactions dans le contexte.

De: 10.3.5.4 Gestion des transactions (mine en gras):

Dans la structure TestContext, les transactions sont gérées par TransactionalTestExecutionListener. Notez que TransactionalTestExecutionListener est configuré par défaut , même si vous ne déclarez pas explicitement @TestExecutionListeners sur votre classe de test. Pour permettre la prise en charge des transactions, vous devez toutefois fournir un bean PlatformTransactionManager dans le contexte d’application chargé par la sémantique @ContextConfiguration . De plus, vous devez déclarer @Transactional au niveau de la classe ou de la méthode pour vos tests .

Mis à part: tentative d’amender la réponse de Tomasz Nurkiewicz a été rejetée:

Cette modification ne rend pas le message encore plus facile à lire, plus facile à trouver, plus précis ou plus accessible. Les modifications sont soit complètement superflues, soit nuisibles à la lisibilité.


Lien correct et permanent vers la section pertinente de la documentation sur les tests d’intégration.

Pour activer la prise en charge des transactions, vous devez configurer un bean PlatformTransactionManager dans ApplicationContext chargé via la sémantique @ContextConfiguration .

 @Configuration
 @PropertySource ("application.properties")
 classe publique Persistence {
     @Autowired
     Environnement env;

     @Haricot
     DataSource dataSource () {
         retourne le nouveau DriverManagerDataSource (
                 env.getProperty ("datasource.url"),
                 env.getProperty ("datasource.user"),
                 env.getProperty ("datasource.password")
         );
     }

     @Haricot
     PlatformTransactionManager transactionManager () {
         renvoyer new DataSourceTransactionManager (dataSource ());
     }
 }

De plus, vous devez déclarer l’annotation @Transactional de Spring au niveau de la classe ou de la méthode pour vos tests.

 @ RunWith (SpringJUnit4ClassRunner.class)
 @ContextConfiguration (classes = {Persistence.class, SomeRepository.class})
 @Transactional
 classe publique SomeRepositoryTest {...}

L’annotation d’une méthode de test avec @Transactional entraîne l’ @Transactional du test dans une transaction qui, par défaut, sera automatiquement annulée à la fin du test. Si une classe de test est annotée avec @Transactional , chaque méthode de test dans cette hiérarchie de classe sera exécutée dans une transaction.

Les réponses mentionnant l’ajout de @Transactional sont correctes, mais pour plus de simplicité, vous pourriez simplement demander à votre classe de test d’ extends AbstractTransactionalJUnit4SpringContextTests .

Je sais, je suis trop tard pour poster une réponse, mais en espérant que cela pourrait aider quelqu’un. De plus, je viens de résoudre ce problème avec mes tests. C’est ce que j’avais dans mon test:

Ma classe de test

 @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "path-to-context" }) @Transactional public class MyIntegrationTest 

Contexte xml

       

J’avais toujours le problème que la firebase database n’était pas nettoyée automatiquement.

Le problème a été résolu lorsque j’ai ajouté la propriété suivante à BasicDataSource

  

J’espère que cela aide.

Vous devez exécuter votre test avec un contexte de sprint et un gestionnaire de transactions, par exemple,

 @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {"/your-applicationContext.xml"}) @TransactionConfiguration(transactionManager="txMgr") public class StudentSystemTest { @Test public void testTransactionalService() { // test transactional service } @Test @Transactional public void testNonTransactionalService() { // test non-transactional service } } 

Voir le chapitre 10. Testing de la référence du ressort pour plus de détails.

Vous pouvez désactiver la restauration:

 @TransactionConfiguration(defaultRollback = false) 

Exemple:

 @RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(classes = Application.class) @Transactional @TransactionConfiguration(defaultRollback = false) public class Test { @PersistenceContext private EntityManager em; @org.junit.Test public void menge() { PersistentObject object = new PersistentObject(); em.persist(object); em.flush(); } }