Tengo un proyecto (ProjectA) que contiene algunas pruebas unitarias y pruebas de integración.

A continuación se muestra la estructura.

ProjectA - src / java (código fuente de java)
- test / java (pruebas unitarias de Junit)
- prueba / recursos (recursos requeridos para las pruebas de la unidad Junit)
- src / java-test (pruebas de integración)
- conf (contiene los archivos .xml necesarios para propósitos de compilación / prueba / compilación)

Ejecuto los siguientes comandos: todos funcionan, pero tengo una duda sobre cómo las configuraciones que tengo en los archivos build.gradle / GRADLE_HOME / init.d / *. Gradle están afectando a lo que estoy obteniendo.

Parece que me estoy perdiendo algo y no estoy llegando a donde quiero qué.

Comandos:
- Gradle Clean Build - funciona bien
- Gradle clean build jacocoTestReport - funciona bien.
- gradle clean build integrationTest jacocoTestReport - funciona bien (si tengo una instancia de Tomcat en funcionamiento en otra ventana de masilla para el mismo ProjectA).

Después de que se complete la tercera operación con viñetas, veo la carpeta "compilación" adicional y sus subcarpetas (aparte de lo que está desprotegido desde el control de fuente / versión) en mi área de trabajo de trabajos de Jenkins.

es decir, bajo - JenkinsWorkspace
/construir
- clases (contiene los archivos .class para lo siguiente que se mencionan como una de las secciones sourceSets)
---- examen de integración
---- principal
---- prueba

- recursos (Esto contiene todos los archivos .properties / .xml que estaban en la carpeta "conf" en el control de código fuente.

- informes (contiene archivos .xml / .html para los resultados de PMD / CheckStyle / Findbugs and Tests para las pruebas de unidad o de TI, pero NO ambas). ---- cheque de estilo
---- encontrar errores
---- pmd
---- jacoco
---- pruebas (Nota: esto es plural, es decir, no es "prueba", que se define como una entrada en sourceSets)

- jacoco (Esto contiene 2 archivos .exec, es decir, test.exec y integrationTest.exec, ambos tienen un tamaño de archivo diferente)
---- test.exec
---- integrationTest.exec

- jacocoHtml (Esta carpeta contiene muchas carpetas (que contienen archivos .html) y principalmente "index.html" debajo de ella.
---- algunas carpetas xxx
---- ---- somexxfolder's.html files
---- index.html
---- otros archivos / carpetas etc

- resultados de la prueba (Esto contiene algunos archivos .xml, PERO solo para pruebas de unidad o pruebas de integración, perono para ambos tipos de prueba en un momento dado).

es decir, si ejecuto "gradle clean build", verás los archivos .xml relacionados con la prueba de la unidad y si ejecuto "gradle clean build integrationTest", los archivos .xml de la prueba de la unidad se sobrescriben y los archivos .xml que veo solo están relacionados a / generado por la tarea de prueba de integración.

A continuación se encuentra uno de los archivos comunes de gradle (GRADLE_HOME / init.d / some.common.gradle)

//
//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' ])
   }
}

construir.gradle archivo se ve como:

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 ) }
   }
}

Mis preguntas:

1) Por qué "Gradle clean build integrationTest", que funciona correctamente, está sobrescribiendo los resultados de las pruebas en las carpetas de compilación / informes / pruebas y compilación / resultados de prueba.

2) No importa el nombre que le dé al archivo .exec en el archivo gradle común para prueba y en build.gradle para integrationTest tarea para jacoco, siempre crea archivos test.exec e integrationTest.exec pero la carpeta de compilación / jacocoHtml resultante El archivo index.html no muestra la cobertura / archivos relacionados con ambas pruebas de Unidad / Integración. Para probar esto, si ejecuto "gradle clean build integrationTest jacocoTestReport sonarRunner", veo el espacio de trabajo para el trabajo, ahora contiene la carpeta ".sonar" y la carpeta build / reports / sonar que contiene otro archivo llamado "overall-xxx.exec "algún archivo, pero ese tamaño de archivo no está cerca de la" suma "de Unit test.exec y IT integrationTest.exec tamaño de archivo. Aunque es más grande que el tamaño del archivo test.exec por unos pocos bytes.

3) ¿Qué configuración puedo configurar para que tenga cobertura general para las pruebas de Unidad y de TI, es decir, en general ... el archivo exec obtiene un buen tamaño (después de ejecutar la tarea de sonarRunner)? Durante la tarea de sonarRunner, veo que el "paso jacocoSensor" de la tarea de SonarRunner sí ve los archivos UT y IT .exec y el archivo .exec general también de forma automática (una buena característica de Sonar).