Ich habe ein Projekt (ProjectA), das einige Unit-Tests und Integrationstests enthält.

Es folgt die Struktur.

ProjectA - src / java (Java-Quellcode)
- test / java (Junit-Unit-Tests)
- Test / Ressourcen (für Junit-Unit-Tests erforderliche Ressourcen)
- src / java-test (Integrationstests)
- conf (enthält .xml-Dateien, die zum Erstellen / Testen / Kompilieren benötigt werden)

Ich führe die folgenden Befehle aus - Alle funktionieren, aber ich habe Zweifel, wie sich die Konfigurationen in den build.gradle / GRADLE_HOME / init.d / *. Gradle-Dateien auf das auswirken, was ich erhalte.

Es scheint, als würde mir etwas fehlen und ich komme nicht dahin, wo ich was will.

Befehle:
- Gradle Clean Build - es funktioniert gut
- gradle clean build jacocoTestReport - es funktioniert gut.
- gradle clean build integrationTest jacocoTestReport - es funktioniert einwandfrei (wenn ich eine Tomcat-Instanz für dasselbe ProjectA in einem anderen Putty-Fenster habe).

Nachdem der dritte Aufzählungsvorgang abgeschlossen ist, werden in meinem Jenkins-Job-Arbeitsbereich der zusätzliche Ordner "build" und seine Unterordner (mit Ausnahme der aus der Versions- / Quellcodeverwaltung ausgecheckten Ordner) angezeigt.

unter - JenkinsWorkspace
/bauen
- Klassen (Enthält .class-Dateien für Folgendes, die als eine der sourceSets-Abschnitten erwähnt werden.)
---- Integrationstest
---- main
---- Prüfung

- Ressourcen (Dies enthält alle Dateien .properties / .xml, die sich in der Quellcodeverwaltung im Ordner "conf" befanden.

- Berichte (Enthält .xml / .html-Dateien für PMD / CheckStyle / Findbugs und Testergebnisse für Unit- oder IT-Tests, jedoch NICHT für beide). ---- Checkstyle
---- Wanzen finden
---- pmd
---- jacoco
---- Tests (Hinweis: das ist Plural, d. h. es ist kein "Test", der als ein Eintrag in sourceSets definiert ist)

- jacoco (Dies enthält 2 .exec-Dateien, d. H. Test.exec und integrationTest.exec haben beide unterschiedliche Dateigrößen.)
---- test.exec
---- integrationTest.exec

- jacocoHtml (Dieser Ordner enthält viele Ordner (mit HTML-Dateien) und hauptsächlich "index.html" darunter.
---- somexxxfolders
---- ---- somexxfolder's.html Dateien
---- index.html
---- andere etc dateien / ordner

- Testergebnisse (Dies enthält einige XML - Dateien, ABER nur für Unit - Tests oder Integrationstestsnicht für beide Testtypen zu einem bestimmten Zeitpunkt).

dh wenn ich "gradle clean build" ausführe, werden Unit-Test-bezogene .xml-Dateien angezeigt, und wenn ich "gradle clean build integrationTest" ausführe, werden Unit-Test-.xml-Dateien überschrieben und die angezeigten .xml-Dateien sind nur verwandt zu / generiert von integrationTest task.

Es folgt eine der allgemeinen Abstufungen (GRADLE_HOME / init.d / some.common.gradle-Datei)

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

build.gradle Datei sieht so aus:

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

Meine Fragen:

1) Warum "gradle clean build integrationTest" - was erfolgreich funktioniert - Testergebnisse in den Ordnern build / reports / tests und build / test-results überschreibt.

2) Es spielt keine Rolle, welchen Namen ich für die .exec-Datei unter der allgemeinen gradle-Datei für den Test und in der build.gradle für die integrationTest-Aufgabe für jacoco gebe. Es werden immer die Dateien test.exec und integrationTest.exec erstellt, aber der resultierende build / jacocoHtml-Ordner Die Datei index.html zeigt keine Abdeckung / Dateien, die sich auf beide Unit- / Integrationstests beziehen. Um dies zu beweisen, wird beim Ausführen von "gradle clean build integrationTest jacocoTestReport sonarRunner" der Arbeitsbereich für den Job angezeigt, der jetzt den Ordner ".sonar" und den Ordner "build / reports / sonar" enthält, der eine andere Datei mit dem Namen "overall-xxx.exec" enthält msgstr "" "eine Datei, aber diese Dateigröße liegt nicht nahe an der" Summe "der Dateigröße von Unit test.exec und IT integrationTest.exec. Obwohl es größer ist als test.exec Dateigröße um einige Bytes.

3) Welche Konfiguration kann ich so einstellen, dass sowohl Unit- als auch IT-Tests insgesamt abgedeckt werden? Die Gesamtgröße der Exec-Datei (nach dem Ausführen der sonarRunner-Task) ist gut. Während der SonarRunner-Task wird angezeigt, dass der "jacocoSensor-Schritt" der SonarRunner-Task sowohl UT- als auch IT-EXEC-Dateien und die gesamte EXEC-Datei automatisch erkennt (eine gute Funktion von Sonar).