Discussion :

[Atatorus]

Bonjour,
j'utilise Sonar 2.10 avec Cobertura sur un projet Maven multi modules, dont 2 modules ne comprennent aucune classe. Ils ne sont constitués que de fichiers de configuration et de classes de tests.
Le problème quand je regarde la couverture des tests avec Sonar, on obtient à peine 50%, alors qu'elle est bien plus importante (j'espère...), une partie des tests ayant lieu dans ces deux modules sans code. J'ai essayé de mettre une classe avec un simple test dans ces modules, mais ça n'a rien changé.
Savez vous s'il est possible de dire à Sonar et Cobertura d'exécuter les tests de ces deux modules ?

Je viens de m'apercevoir que Sonar exécute bien les tests dans mes 2 modules sans classes, mais ne les comptent pas pour ce qui est de la couverture des tests. À priori, il ne calcule le taux de couverture qu'à l'intérieur du même module.

Merci.

[Atatorus]

Bonjour,
nous avons finalement réussi à obtenir la mesure de la couverture globale de notre code avec les tests répartis dans plusieurs modules. Le problème venait du fait que Cobertura ne mesure la couverture qu'à l'intérieur d'un module. En effet, pour ceci, il instrumente les classes, mais quand maven exporte les jar des différents modules, il exporte des jars non instrumentés. Il faut donc instrumenter les jars dans les autres modules, sans les mélanger avec ceux qui seront déployés.
Nous avons trouvé la solution grâce aux informations glanés, entre autres sites, ici :
http://seamframework.org/Documentati...eWithCobertura
et là :
http://foobar.lacoctelera.net/post/2...ulti-modulo-en

Notre solution consiste à utiliser des profils. Voici un extrait du pom.xml de nos modules "normaux", c'est à dire ceux contenant seulement les tests unitaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
        <profile>
            <id>cobertura</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-jar-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>cobertura-jar</id>
                                <phase>compile</phase>
                                <goals>
                                    <goal>jar</goal>
                                </goals>
                                <configuration>
                                    <classifier>cobertura</classifier>
                                    <classeDirectory>${basedir}/target/generated-classes/cobertura</classeDirectory>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-install-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>cobertura-install</id>
                                <phase>compile</phase>
                                <goals>
                                    <goal>install</goal>
                                </goals>
                                <configuration>
                                    <classifier>cobertura</classifier>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

Les jars instrumentés sont donc ceux avec le classifier cobertura. Ensuite, nous avons indiqué à nos modules de test fonctionnel d'utiliser ces jars instrumentés à la place des jars normaux, toujours à l'aide de profils :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
         <profile>
            <id>cobertura</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>build-helper-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>add-source</id>
                                <phase>generate-sources</phase>
                                <goals>
                                    <goal>add-source</goal>
                                </goals>
                                <configuration>
                                    <sources>
                                        <source>${basedir}/../module1/src/main/java</source>
                                        <source>${basedir}/../module2/src/main/java</source>
                                        <source>${basedir}/../module3/src/main/java</source>
                                    </sources>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
 
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>cobertura-maven-plugin</artifactId>
                        <dependencies>
                            <dependency>
                                <groupId>groupId</groupId>
                                <artifactId>module1</artifactId>
                                <version>1.0-SNAPSHOT</version>
                                <classifier>cobertura</classifier>
                            </dependency>
                            <dependency>
                                <groupId>groupId</groupId>
                                <artifactId>module2</artifactId>
                                <version>1.0-SNAPSHOT</version>
                                <classifier>cobertura</classifier>
                            </dependency>
                            <dependency>
                                <groupId>groupId</groupId>
                                <artifactId>module3</artifactId>
                                <version>1.0-SNAPSHOT</version>
                                <classifier>cobertura</classifier>
                            </dependency>
                        </dependencies>
                    </plugin>
                </plugins>
            </build>
        </profile>

Pour mesurer la couverture des tests, il nous suffit donc de faire :
mvn -Pcobertura cobertura:cobertura
On retrouve dans target/site/cobertura de nos modules de tests fonctionnels le rapport sur la couverture des tests fonctionnels. Il reste toujours possible d'utiliser maven normalement (mvn test install par exemple), notamment sur notre serveur d'intégration continue sans mélanger les jars normaux et instrumentés.
Nous avons également écrit un petit script qui fusionne les couvertures des tests unitaires et fonctionnels :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#!/bin/bash
 
COBERTURA_HOME=~/cobertura-1.9.4.1
RESULT_HOME=~/cobertura
PROG_HOME=~/sources/
 
 
echo "------------------------------------"
echo "Lancement de la couverture des tests"
echo "------------------------------------"
cd $PROG_HOME
mvn -Pcobertura cobertura:cobertura
 
rm -Rf $RESULT_HOME/*
 
echo "--------------------"
echo "Fusion des résultats"
echo "--------------------"
cobertura_files=""
for file in `find $PROG_HOME -name *.ser`;do cobertura_files="$file $cobertura_files"; done
$COBERTURA_HOME/cobertura-merge.sh $cobertura_files --datafile $RESULT_HOME/cobertura.ser
 
echo "---------------------"
echo "Génération du rapport"
echo "---------------------"
 
source_files=`echo $cobertura_files | sed -e 's/target\/cobertura\/cobertura.ser/src\/main\/java\//g'`
$COBERTURA_HOME/cobertura-report.sh --source $source_files --destination $RESULT_HOME --datafile $RESULT_HOME/cobertura.ser 
 
cd -

Tout ceci fonctionne très bien, et nous obtenons la couverture globale de nos tests.
Je dois également avouer que nous ne sommes pas des experts en Maven, et que cette solution est très certainement améliorable. De plus, nous n'avons toujours pas réussi à intégrer ces résultats dans sonar, même en le lançant avec mvn -Pcobertura sonar:sonar

Merci à ceux qui auraient une idée de m'en faire part.