Tests unitaires et d'intégration avec les catégories Maven et JUnit

Cet exemple montre comment fractionner les tests unitaires et d'intégration à l'aide des catégories Maven et JUnit.

Il est particulièrement utile pour les suites de tests existantes et peut être implémenté en quelques minutes.

Mon article précédent montrait comment utiliser un profil maven pour séparer les tests unitaires et d'intégration.

//johndobie.blogspot.co.uk/2011/06/seperating-maven-unit-integration-tests.html

Cet article a été très bien lu et j'aime la façon dont il utilise des répertoires séparés. Cependant, cet exemple montre une technique beaucoup plus simple qui peut facilement être appliquée aux suites de tests héritées.

Il offre la plupart des avantages de l'original et s'intègre plus confortablement dans le monde Maven.

Le code de l'exemple est ici.

svn co //designbycontract.googlecode.com/svn/trunk/examples/maven/categor... mvn clean install 

Depuis JUnit 4.8, vous pouvez définir vos propres catégories de tests. Cela vous permet d'étiqueter et de regrouper les tests.

Cet exemple montre à quel point il est facile de séparer les tests unitaires et d'intégration à l'aide de l'annotation @Catgegory.

//kentbeck.github.com/junit/javadoc/latest/org/junit/experimental/categories/Categories.html

La première étape du regroupement d'un test à l'aide de catégories consiste à créer une interface de marqueurs.

Cette interface sera utilisée pour marquer tous les tests que vous souhaitez exécuter comme tests d'intégration.

public interface IntegrationTest {} 

Ajoutez l'annotation de catégorie en haut de votre classe de test. Il prend le nom de votre nouvelle interface.

import org.junit.experimental.categories.Category; @Category(IntegrationTest.class) public class ExampleIntegrationTest{ @Test public void longRunningServiceTest() throws Exception { } } 

Les catégories peuvent être utilisées pour marquer des classes ou des méthodes. Vraiment, à mon avis, vous ne devriez marquer qu'une classe.

Si vous avez à la fois des tests unitaires et d'intégration dans une seule classe, divisez-la.

La beauté de cette solution est que rien ne change vraiment pour le côté test unitaire des choses.

Nous ajoutons simplement une configuration au plugin maven surefire pour qu'il ignore les tests d'intégration.

 org.apache.maven.plugins maven-surefire-plugin 2.11   org.apache.maven.surefire surefire-junit47 2.12     **/*.class  com.test.annotation.type.IntegrationTest   

Il y a 2 parties très importantes. La première consiste à configurer surefire pour exclure tous les tests d'intégration.

com.test.annotation.type.IntegrationTest 

Surefire exécutera tous vos tests, à l'exception de ceux marqués comme test d'intégration.

L'autre partie importante est de s'assurer que le plugin infaillible utilise le bon fournisseur JUnit. Le fournisseur JUnit47 est nécessaire pour détecter correctement les catégories.

  org.apache.maven.surefire surefire-junit47 2.12   

Pour nous assurer que cela fonctionne correctement, nous pouvons exécuter les tests unitaires

mvn clean test 

Vous pouvez voir dans la sortie ci-dessous que le test unitaire est exécuté, mais pas le test d'intégration.

------------------------------------------------------- T E S T S ------------------------------------------------------- Running com.test.EmptyUnitTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec Results : Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ 

Encore une fois, la configuration est très simple.

Nous utilisons le plugin de sécurité standard et le configurons pour exécuter uniquement les tests d'intégration.

 maven-failsafe-plugin 2.12   org.apache.maven.surefire surefire-junit47 2.12    com.test.annotation.type.IntegrationTest     integration-test    **/*.class      

La configuration utilise un objectif d'exécution standard pour exécuter le plug-in de sécurité pendant la phase de test d'intégration de la construction.

La configuration suivante garantit que seuls les tests d'intégration sont exécutés.

com.test.annotation.type.IntegrationTest 

Et encore une fois, le fournisseur JUnit doit être correctement configuré.

  org.apache.maven.surefire surefire-junit47 2.12   

C'est ça!

Nous pouvons maintenant exécuter la version complète.

mvn clean install 

Cette fois ainsi que le test unitaire en cours d'exécution, les tests d'intégration sont exécutés pendant la phase de test d'intégration.

------------------------------------------------------- T E S T S ------------------------------------------------------- Running com.test.AnotherEmptyIntegrationTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.016 sec Running com.test.EmptyIntegrationTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec Results : Tests run: 2, Failures: 0, Errors: 0, Skipped: 0 

Pour voir à quel point il est facile d'ajouter une couverture de code à cette méthode, consultez ce lien.

//johndobie.blogspot.co.uk/2012/05/easy-unit-and-integration-code-coverage.html

Pour un exemple plus complet qui utilise démarre Tomcat et une base de données.

svn co //designbycontract.googlecode.com/svn/trunk/examples/maven/code-co... mvn clean install -Ptomcat-embedded 

C'est basé sur cet exemple

//johndobie.blogspot.com/2011/10/maven-integration-testing-and-spring.html

Cette histoire, "Tests unitaires et d'intégration avec les catégories Maven et JUnit" a été initialement publiée par JavaWorld.