Jacoco Tests Unitaires et d'Intégration de la couverture individuelle et globale

J'ai un projet (ProjectA) qui contient des tests unitaires et des tests d'intégration.

Voici la structure.

ProjectA
- src/java (java code source)
- test/java (Junit tests d'unité)
- test/resources (ressources nécessaires pour les tests Unitaires Junit)
- src/java-test (tests d'Intégration)
- conf (contient .xml les fichiers requis pour le bâtiment/test/compilation de buts)

Je exécutez les commandes suivantes -- Tous fonctionne mais j'ai un doute sur la façon dont les configurations que j'ai dans la construction.gradle /GRADLE_HOME/init.d/*.gradle fichiers affectent ce que je suis.

Il me semble que je suis absent quelque chose et de ne pas aller là où je veux ce qui.

Commandes:
- gradle propre build -- il fonctionne très bien
- gradle construction propre jacocoTestReport -- il fonctionne très bien.
- gradle construction propre integrationTest jacocoTestReport -- il fonctionne très bien (si j'ai un tomcat instance et en cours d'exécution dans un autre mastic de fenêtre pour la même ProjectA).

Après la 3ème balle opération est terminée, je vois le dossier extra "construction" et de ses sous-dossiers (autre que ce qui est extraite à partir de la source de contrôle de version) dans mon Jenkins emplois de l'espace de travail.

c'est à dire sous -- JenkinsWorkspace
/construire
- classes (contient .les fichiers de classe pour les suivants qui sont mentionné comme l'un des sourceSets section)
---- integrationTest
---- principales
---- test

- ressources (qui contient tous les fichiers .properties/.xml les fichiers qui ont été en vertu de la "conf" dans le dossier de contrôle à la source.

- rapports (contient .xml/.html fichiers pour PMD/CheckStyle/Findbugs et les résultats des Tests, soit de l'Unité ou des Tests, mais PAS les deux).
---- checkstyle
---- findbugs
---- pmd
---- jacoco
---- tests (Note: c'est pluriel, c'est à dire qu'il n'est pas "test" qui est défini comme une entrée dans sourceSets)

- jacoco (qui contient 2 .exec c'est à dire des fichiers de test.exec et integrationTest.exec ont tous deux différents de taille de fichier)
---- test.exec
---- integrationTest.exec

- jacocoHtml (Ce dossier contient de nombreux dossiers (contenant .les fichiers html) et surtout "index.html".
---- somexxxfolders
---- ---- somexxfolder's.html fichiers
---- index.html
---- autres etc fichiers/dossiers

- test-résultats (il contient quelques .de fichiers xml, MAIS uniquement pour les tests Unitaires ou d'Intégration, tests - mais pas pour les deux types de test à un moment donné).

c'est à dire si je lance "gradle propre build", puis vous allez voir le test de l'Unité relative .des fichiers xml et
si je lance "gradle construction propre integrationTest", puis de l'Unité de test .les fichiers xml sont remplacés
et le .fichiers xml je vois ne sont liées qu'à/généré par integrationTest tâche.

Voici une des communes gradle (GRADLE_HOME/init.d/certains.commun.gradle fichier)

//
//Extra file can hold global Gradle settings so that these dont have to be inserted in project
//specific build.gradle file.
//Filename: extraN.common<anyname>.gradle
allprojects {
   apply plugin: 'java'
   apply plugin: 'pmd'
   apply plugin: 'findbugs'
   apply plugin: 'checkstyle'
   apply plugin: 'jacoco'
   apply plugin: 'sonar-runner'
   tasks.withType(Compile) {
     options.debug = true
     options.compilerArgs = ["-g"]
   }
   sourceSets {
      main {
         java {
            //MOTE: If your project's build.gradle specify the sourceSet section, the following
            //values will be overwritten by what project's build.gradle will set.
            //
            //If you project's sourceSet structure if different in each project, then in this
            //global common .gradle file, you can define srcDir for main or other sections like
            //test, integrationTest etc as shown below -- commented out. If that's the case, 
            //then uncomment the below line and comment out using //-- srcDir 'src/java' line
            //for sourceSets.main.java section. This rule applies to other sections as well.
            //srcDir 'no_src_dir_set_yet'

            srcDir 'src/java'
         }
         resources {
            srcDir 'conf'
         }
      }
      test {
         java {
            srcDir 'test/java'
         }
         resources {
            srcDir 'test/resources'
            srcDir 'conf'
         }
      }
      integrationTest {
         java {
            srcDir 'src/java-test'
         }
         resources {
            srcDir 'conf'
         }
      }
   }
   def sonarServerUrl = "dev.sandbox.server.com"
   sonarRunner {
      sonarProperties {
         property "sonar.host.url", "http://$sonarServerUrl:9000"
         property "sonar.jdbc.url", "jdbc:h2:tcp://$sonarServerUrl:9092/sonar"
         property "sonar.jdbc.driverClassName", "org.h2.Driver"
         property "sonar.jdbc.username", "sonar"
         property "sonar.jdbc.password", "sonar"
         properties ["sonar.sources"] += sourceSets.main.allSource.srcDirs
         //properties ["sonar.tests"] += sourceSets.test.java.srcDirs
         properties ["sonar.tests"] += sourceSets.integrationTest.allSource.srcDirs
      }
   }
   checkstyle {
        configFile = new File(rootDir, "config/checkstyle.xml")
        ignoreFailures = true
        //sourceSets = [sourceSets.main, sourceSets.test, sourceSets.integrationTest]
        sourceSets = [sourceSets.main]
   }
   findbugs {
        ignoreFailures = true
        sourceSets = [sourceSets.main]
   }
   pmd {
        ruleSets = ["basic", "braces", "design"]
        ignoreFailures = true
   }
   jacoco {
      toolVersion = "0.6.2.201302030002"
      reportsDir = file("$buildDir/customJacocoReportDir")
   }
   task testReport(type: TestReport) {
      destinationDir = file("$buildDir/reports/allTests")
   }
   test {
        jacoco {
            //destinationFile = file("$buildDir/jacoco/jacocoTest.exec")
            destinationFile = file("$buildDir/jacoco/test.exec")
            //classDumpFile = file("$buildDir/jacoco/classpathdumps")
            classDumpFile = file("$buildDir/build/classes/test")
        }
   }
   jacocoTestReport {
         group = "Reporting"
         description = "Generate Jacoco coverage reports after running tests."
         reports {
                xml{
                    enabled true
                    destination "${buildDir}/reports/jacoco/jacoco.xml"
                }
                csv.enabled false
                html{
                    enabled true
                    destination "${buildDir}/jacocoHtml"
                }
        }
        additionalSourceDirs = files(sourceSets.main.allJava.srcDirs)
        //additionalSourceDirs = files([sourceSets.main.allJava.srcDirs, xxxx, 'xxxxyyyy' ])
   }
}

construire.gradle fichier ressemble à ceci:

import com.tr.ids.gradle.CustomFileUtil
apply plugin: 'CustomSetup'
apply plugin: 'java'
apply plugin: 'customJarService'
apply plugin: 'customWarService'
sourceSets {
   main {
      java {
         srcDir 'src/java'
      }
   }
   test {
      java {
         srcDir 'test/java'
      }
      resources {
         srcDir 'test/resources'
         srcDir 'conf'
      }
   }
   integrationTest {
      java {
         srcDir 'src/java-test'
      }
   }
}
//Read dependency lists from external files. Our custom plugin reads a dep-xxx.txt file for compile/test/war related .jar file entries
//where each entry is like: groupid:artifactid:x.x.x
//and these artifact jars are available in Artifactory
List depListCompile = customFileUtil.readIntoList( "$projectDir/dep-compile.txt" )
List depListTest = customFileUtil.readIntoList( "$projectDir/dep-testArtifacts.txt" )
List depListWar = customFileUtil.readIntoList( "$projectDir/dep-war.txt" )
//Define dependencies
dependencies {
   //Compilation
   compile  depListCompile
   //Unit Tests
   testCompile depListTest
   //Integration tests
   //Everything from compile and testCompile targets
   integrationTestCompile configurations.compile
   integrationTestCompile configurations.testCompile
   //Output of compiling "main" files
   integrationTestCompile sourceSets.main.output
   //Additional dependencies from war and others
   integrationTestCompile depListTest, depListWar
   //All configuration files
   integrationTestRuntime files( 'conf' )
}
task deployTomcat( type: Copy, dependsOn: [ jar, compileIntegrationTestJava, warService ] ) {
   from "$buildDir/customWar/${project.name}.war"
   into "$projectDir/tomcat/webapps"
}
build {
  dependsOn deployTomcat
}
task integrationTest( type: Test, dependsOn: cleanTest ) {
   jacoco {
      //destinationFile = file("$buildDir/jacoco/jacocoTest.exec")
      destinationFile = file("$buildDir/jacoco/integrationTest.exec")
      //classDumpFile = file("$buildDir/jacoco/classpathdumps")
      classDumpFile = file("$buildDir/classes/integrationTest")
   }
   testClassesDir = sourceSets.integrationTest.output.classesDir
   classpath = sourceSets.integrationTest.runtimeClasspath
}
apply plugin: 'eclipse'
eclipse.classpath {
   //Define output directory so Eclipse does not accidentally clobber /bin
   defaultOutputDir = file( 'out/classes' )
   //Add integration test
   plusConfigurations += configurations.integrationTestCompile
   //Remove unnecessary files
   file.whenMerged { classpath ->
      classpath.entries.removeAll { entry -> ( entry.path.indexOf( '/build/classes/main' ) > 0 ) }
      classpath.entries.removeAll { entry -> ( entry.path.indexOf( '/build/resources/main' ) > 0 ) }
   }
}

Mes questions:

1) Pourquoi "gradle construction propre integrationTest" -- qui est couronnée de succès, est d'écraser les résultats de test dans build/rapports/tests et de construire/test-résultats des dossiers.

2) Il n'est pas n'importe quel nom que je donne .exec fichier en vertu de la common gradle fichier de test et dans la construction.gradle pour integrationTest tâche pour jacoco, il est toujours créer le test.exec et integrationTest.exec fichier, mais la résultante de construction/jacocoHtml dossier index.html fichier ne montre pas de couverture /les fichiers liés à la fois aux tests Unitaires et d'Intégration. Pour le prouver, si je lance "gradle construction propre integrationTest jacocoTestReport sonarRunner", je vois l'espace de travail pour le travail, maintenant contient ".sonar" de dossier et de construire/rapports/sonar dossier qui contient un fichier appelé "l'ensemble-xxx.exec" certains fichiers, mais que la taille du fichier n'est pas proche de la "somme" de l'Unité de test.exec et IL integrationTest.exec taille du fichier. Mais sa plus grande que test.exec taille du fichier de quelques octets.

3) Quelle configuration puis-je avoir une couverture globale pour à la fois l'Unité et de tests, par exemple ensemble...exec fichier est de bonne taille (après l'exécution de sonarRunner tâche). Au cours de sonarRunner tâche, je ne vois SonarRunner de la tâche "jacocoSensor étape" de voir les deux UT et IL .exec fichiers et le global .exec fichier automatiquement (une bonne fonctionnalité à partir de Sonar).

OriginalL'auteur Arun Sangal | 2013-09-18