Le titre de ce billet montre bien l'étendue des thèmes qui seront traités. Il a pour objectif d'illustrer, à l'aide d'un exemple assez complet et proche des cas réels, la mise en place des tests, en mode transactionnel, pour les différentes couches applicatives.Ainsi les vraies difficultés rencontrées par les développeurs seront évoquées.
Le billet traite JUnit4 enrichi avec les annotations de Spring2.5+ et ses lanceurs pour exécuter facilement les tests. Des illustrations en mode transactionnel vous sont proposées à la fin de ce billet.
Le framework JUnit est l'oeuvre conjointe de Kent Beck (créateur de XP) et Erich Gamma (auteur des Design Patterns).
Avec la version 4, JUnit tente de rattraper son retard sur Testng tout en gardant la compatibilité avec JUnit3x ainsi qu'une parfaite intégration aux éditeurs Eclipse, Netbeans, ...

La pratique des tests unitaires est l'un des principes des méthodes agiles. Il semble que tous les nouveaux frameworks renforcent le principe de testabilité de toutes les couches applicatives.
Avec JUnit4 et Spring, les tests, en particulier d'intégration, deviennent aisés. Ceux ayant pratiqués les tests savent bien les efforts nécessaires afin de tester certaines couches(par exemple, la couche de persistance ou DAO).
Citons au passage, un critère majeur permettant de juger de la suffisance des tests peut être :
L'investissement fait en tests doit être égal à celui passé sur le design. Et si le design répond facilement au changement alors les tests sont suffisants.
L'un des avantages des tests est d'avoir un retour (feedback) rapide et beaucoup moins cher sur les réglages à apporter au logiciel et ainsi d'anticiper les anomalies.
Le second avantage des tests (unitaires et d'intégration) est de limiter le nombre d'itérations (en phase recette/production) de mise en conformité du logiciel.
Et, par conséquent, de réduire son coût total du logiciel. En phase de mise en recette/production les personnes impliquées sont de diverses compétences d'où le coût économique élevé d'une itération à ce stade!

La bonne compréhension de ce billet nécessite d'avoir certains pré-requis énoncés plus loin. A défaut, au préalable, lire l'article sur le blog Netapsys.

L'utilisation de Spring avec JUnit4 n'exige en aucun cas de maîtriser Spring.

La présentation de ce billet est divisée en trois grandes parties:

• Créer une application Web Java JEE avec Maven2, SpringMVC et ses annotations (en particulier @Controller. Voir l'article sur le blog de Netpsys pour les étapes de création d’un projet sous eclipse avec maven2),
• Mettre en place, via le framework JUnit4.x, des tests unitaires et d'intégration couvrant l'ensemble des couches applicatives (couches Dao, Service et Web en SpringMVC),
• Enfin, exécution des tests en mode transactionnel. Les codes sources présentés sont disponibles en annexe.

CREATION D'UNE APPLICATION WEB SPRINGMVC

PREREQUIS

Les pré-requis suivants aideront à lire facilement ce billet. Mais tous ne sont pas nécessaires à sa compréhension.

1. Connaissance des applications Web dans le monde JEE (servlet, jsp..),
2. Connaissance sommaire de Spring, SpringMVC avec ses annotations,
3. Connaissance sommaire de JUnit4.x et ses annotations ;
4. Connaissance sommaire de la notion de transaction.

ETAPE 1. Application Web avec Spring MVC

Pour toute la suite, l’application Web exemple sera nommée «spring-mvc-webapp». C’est le nom de la servlet frontale dans le fichier web.xml.
Commençons par configurer le fichier web.xml dont voici le contenu (certaines lignes peuvent encore être simplifiées mais sont laissées ici pour une meilleure compréhension) :

<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/spring-mvc-webapp-servlet.xml, classpath:/spring.xml
</param-value>
</context-param>
 
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- déclare la servlet frontal -->
<servlet>
<servlet-name>spring-mvc-webapp</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- les requêtes se terminant par .html sont servies par cette servlet -->
<servlet-mapping>
<servlet-name>spring-mvc-webapp</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</web-app>

Le suite de l'article sur le blog.