Mise en oeuvre de TestNG : Ant versus Gradle

TestNG est un framework de test basé sur Junit apportant plusieurs fonctionnalités comme

• Distribution sur plusieurs machines
• Modèle d’exécution avancé
• Configuration flexible

Ce billet montre un exemple de mise en œuvre du framework TestNG avec le builder Ant et le builder Gradle.

Dans l’exemple de ce billet, nous avons en entrée la structure suivante

• src/test/java : contient nos sources de tests TestNG
• src/test/resources : contient nos ressources de tests, en particulier le fichier TestNG “testng.xml” décrivant la suite de tests à exécuter

1. <suite name=“SuiteExample” verbose=“1” >
2. <test name=“TestSetApp” annotations=“JDK” verbose=“1”>
3. <classes>
4. <class name=“com.zenika.example1.AppTest” />
5. </classes>
6. </test>
7. </suite>

Ce fichier sera utilisé uniquement dans le cadre de Ant. En Gradle, nous avons choisis de générer dynamiquement ce fichier.

Cas du builder Ant

1. <project name=“testng-example”>
3. <property name=“test.src” value=“src/test/java”/>
4. <property name=“test.resources.dir” value=“src/test/resources”/>
5. <property name=“build.dir” value=“build”/>
6. <property name=“test.build.dir” value=“${build.dir}/test-classes”/>
7. <property name=“testng.result.dir” value=“${build.dir}/test-results”/>
8. <property name=“testng.report.dir” value=“${build.dir}/reports/tests”/>
10. <path id=“testng.classpath”>
11. <pathelement location=“lib/testng-5.8-jdk15.jar”/>
12. </path>
14. <path id=“test.compile”>
15. <path refid=“testng.classpath”/>
16. </path>
18. <path id=“test.run”>
19. <path refid=“test.compile”/>
20. <path location=“${test.build.dir}”/>
21. </path>
23. <target name=“clean”>
24. <delete dir=“${testng.result.dir}”/>
25. <delete dir=“${testng.report.dir}”/>
26. <delete dir=“${test.build.dir}”/>
27. <delete dir=“${build.dir}”/>
28. </target>
30. <target name=“test-init”>
31. <mkdir dir=“${build.dir}”/>
32. <mkdir dir=“${test.build.dir}”/>
33. <mkdir dir= “${testng.result.dir}”/>
34. <mkdir dir=“${testng.report.dir}”/>
35. </target>
37. <target name=“test-compile” depends=“test-init”>
38. <javac srcdir=“${test.src}” source=“1.5” target=“1.5” destdir=“${test.build.dir}”>
39. <classpath refid=“test.compile”/>
40. </javac>
41. </target>
43. <target name=“test-run” depends=“test-compile”>
45. <taskdef name=“testng”
46. classname=“org.testng.TestNGAntTask” classpathref=“testng.classpath”/>
48. <testng classpathref=“test.run”
49. outputDir=“${testng.report.dir}”>
50. <xmlfileset dir=“${test.resources.dir}” includes=“testng.xml”/>
51. </testng>
53. </target>
55. <target name=“test-report” depends=“test-run”>< /span>
56. <junitreport todir=“${testng.result.dir}”>
57. <fileset dir=“${testng.report.dir}”>
58. <include name=“*/*.xml”/>
59. </fileset>
60. <report format=“noframes” todir=“${testng.report.dir}”/>
61. </junitreport>
62. </target>
64. </project>

Nous définissons plusieurs paths dont un path “testng.classpath” contenant la librairie “testng”. La librairie est située à la racine du projet dans un répertoire “lib”. Ensuite, le script Ant contient les cibles suivantes

• Une cible “test-init” qui va créer l’ensemble des répertoires nécessaires
• Une cible “test-compile” qui va compiler notre code source de tests
• Une cible “test-run” qui va executer les tests TestNG. Cette cible charge la tâche Ant “testng” puis l’invoque avec en entrée le fichier de ressources “testng.xml”. Il est à noter que la librairie testng est utile pour le classpath d’exécution et contient également la tâche Ant

Appel

L’invocation de la commande “ant clean test-report” détruit tous les éventuels résultats précédents, puis lance les tests; enfin un rapport Junit HTML est produit.

Cas du builder Gradle

Avec le builder Gradle, nous avons le script suivant

1. usePlugin(‘java’)
3. repositories {
4. flatDir name: ‘localRepository’, dirs: ‘lib’
5. }
7. dependencies {
8. testCompile “:testng:5.8:jdk15”
9. }
11. test {
12. setStopAtFailuresOrErrors(false)
13. enableTestReport()
14. useTestNG() {
15. suiteXmlBuilder().suite(name: ‘testing-testng’& #41; {
16. test (name : ‘testing-testng’, annotations : ‘JDK’, verbose:‘1’) {
17. classes {
18. ‘class’ (name: ‘com.zenika.example1.AppTest’)
19. }
20. }
21. }
22. }
23. }
26. task reportTests(dependsOn:test) <<{
27. ant{
28. junitreport(todir:testResultsDir){
29. fileset(dir:testReportDir){
30. include(name:“**/*.xml”)
31. }
32. report(format:“noframes”, todir:testReportDir)
33. }
34. }
35. }

Tout premièrement, nous définissions l’utilisation du plugin “java” qui fournit les conventions de répertoires (en particulier “src/test/java” pour les sources Java des tests) et un ensemble de tâches (en particulier “compileTests” et “test” pour la compilation et l’exécution des tests).
Nous avons ensuite la section suivante décrivant les entrepôts de librairies et la récupération de ces librairies.

1. repositories {
2. flatDir name: ‘localRepository’, dirs: ‘lib’
3. }
5. dependencies {
6. testCompile “:testng:5.8:jdk15”
7. }

Nous déclarons l’utilisation de la librairie “testng” dans un repository local, localisé dans le répertoire “lib” à la racine du projet.
Puis dans la tâche “test”, nous définissions explicitement les points suivant

• Ne pas arrêter le build si un test est en erreur ou en failure
• Générer un rapport de test
• Une suite de test TestNG. Elle est construite dynamiquement, avec le même contenu que le fichier “testng.xml” utilisé précédemment pour Ant.

Enfin, nous définissions une tâche de reporting pour produire un rapport Junit HTML de nos tests TestNG. Pour cela, nous avons redéfinit la tâche Ant junitreport.

Appel

L’invocation de la commande “gradle clean reportTests” détruit tous les éventuels résultats précédents, puis lance les test
s; enfin un rapport Junit HTML est produit.