java - Filtrar informes de cobertura de JaCoCo con Gradle

unit-testing code-coverage

Question

Problema:

Tengo un proyecto con jacoco y quiero poder filtrar ciertas clases y / o paquetes.

Documentación relacionada:

He leído la siguiente documentación:

Sitio oficial de jacoco : http://www.eclemma.org/jacoco/index.html

Documentos oficiales de jacoco para gradle : https://gradle.org/docs/current/userguide/jacoco_plugin.html

jacoco oficiales de jacoco Github , trabajando en cobertura: https://github.com/jacoco/jacoco/wiki/FilteringOptions https://github.com/jacoco/jacoco/issues/14

Enlaces relacionados de StackOverflow:

JaCoCo & Gradle - Opciones de filtrado (Sin respuesta)

Excluir paquetes del informe Jacoco usando Sonarrunner y Gradle (sin usar sonar )

JaCoCo: excluir JSP del informe (parece funcionar para maven , estoy usando gradle )

Configuración de Maven Jacoco: excluir clases / paquetes del informe que no funciona (parece funcionar para maven , estoy usando gradle )

Exclusión del complemento de gradle JaCoCo (No se pudo hacer que esto funcione)

Gradle Jacoco: los informes de cobertura incluyen clases excluidas en la configuración (parece muy cercano, usó doFirst , no funcionó para mí)

Ejemplo de lo que he intentado:

apply plugin: ''java''
apply plugin: ''jacoco''

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }
}

repositories {
    jcenter()
}

jacocoTestReport {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    test {
        jacoco {
            destinationFile = file("$buildDir/jacoco/jacocoTest.exec")
            classDumpFile = file("$buildDir/jacoco/classpathdumps")
            excludes = ["projecteuler/**"] // <-- does not work
            // excludes = ["projecteuler"]
        }
    }
}

Pregunta:

¿Cómo puedo excluir ciertos paquetes y clases al generar los informes de cobertura de jacoco ?

Answer 1

Gracias a Yannick Welsch :

Después de buscar en Google, leer los documentos de Gradle y revisar publicaciones anteriores de StackOverflow, ¡encontré esta respuesta en los foros oficiales de gradle !

jacocoTestReport {
    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it, exclude: ''com/blah/**'')
        })
    }
}

Fuente: https://issues.gradle.org/browse/GRADLE-2955

Solución a mi build.gradle para proyectos Java / Groovy:

apply plugin: ''java''
apply plugin: ''jacoco''

jacocoTestReport {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it,
                    exclude: [''codeeval/**'',
                              ''crackingthecode/part3knowledgebased/**'',
                              ''**/Chapter7ObjectOrientedDesign**'',
                              ''**/Chapter11Testing**'',
                              ''**/Chapter12SystemDesignAndMemoryLimits**'',
                              ''projecteuler/**''])
        })
    }
}

Como puede ver, pude agregar más para exclude: para filtrar algunos paquetes.

Fuente: https://github.com/jaredsburrows/CS-Interview-Questions/blob/master/build.gradle

Tareas personalizadas para otros proyectos como Android:

apply plugin: ''jacoco''

task jacocoReport(type: JacocoReport) {
    reports {
        xml {
            enabled true // coveralls plugin depends on xml format report
        }

        html {
            enabled true
        }
    }

    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it,
                    exclude: [''codeeval/**'',
                              ''crackingthecode/part3knowledgebased/**'',
                              ''**/Chapter7ObjectOrientedDesign**'',
                              ''**/Chapter11Testing**'',
                              ''**/Chapter12SystemDesignAndMemoryLimits**'',
                              ''projecteuler/**''])
        })
    }
}

Fuente: https://github.com/jaredsburrows/android-gradle-java-app-template/blob/master/gradle/quality.gradle#L59

Answer 2

El siguiente código excluye las clases de la verificación de cobertura también:

jacocoTestCoverageVerification {
    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: "${project.buildDir}/classes/main",
                    exclude: [''**/packagename/**''])
        })
    }
}

Answer 3

Esto ha estado fuera por un tiempo, pero me encontré con esto. Estaba luchando con todas las exclusiones necesarias. Descubrí que era algo mucho más simple para mí. Si sigue el estilo de diseño del proyecto Maven / src / main / java y / src / test / java, simplemente necesita poner buildDir / classes / main en la configuración de classDirectories de esta manera:

afterEvaluate {
    jacocoTestReport {
        def coverageSourceDirs = [''src/main/java'']
        reports {
            xml.enabled false
            csv.enabled false
            html.destination "${buildDir}/reports/jacocoHtml"
        }
        sourceDirectories = files(coverageSourceDirs)
        classDirectories = fileTree(
                dir: "${project.buildDir}/classes/main",
                excludes: [
                      //whatever here like JavaConfig etc. in /src/main/java
                     ]
        )
    }
}

Answer 4

Para Gradle versión 5.0 y posterior, classDirectories = files(...) da una advertencia de desaprobación. Esta es la forma no obsoleta de excluir clases:

jacocoTestReport {
    afterEvaluate {
        classDirectories.setFrom(files(classDirectories.files.collect {
            fileTree(dir: it, exclude: ''com/exclude/**'')
        }))
    }
}

Answer 5

agregue la siguiente configuración en el archivo gradle.properties

coverageExcludeClasses=["com.example.package.elasticsearch.*", "com.example.package2.*",]

Answer 6

algunos comentarios mencionaron la advertencia de desaprobación. para resolver solo use el getter:

afterEvaluate { getClassDirectories().from(files(classDirectories.files.collect { fileTree(dir: it, exclude: ''com/blah/**'') })) }

Answer 7

para mí, está bien trabajar con

test {
  jacoco {
    excludes += [''codeeval/**'',
                 ''crackingthecode/part3knowledgebased/**'',
                 ''**/Chapter7ObjectOrientedDesign**'',
                 ''**/Chapter11Testing**'',
                 ''**/Chapter12SystemDesignAndMemoryLimits**'',
                 ''projecteuler/**'']
  }
}

como se indica en la documentación https://docs.gradle.org/current/userguide/jacoco_plugin.html#N16E62 y se preguntó inicialmente, por lo que la respuesta es:

así que si me preguntas: no es una cuestión de

excludes = ["projecteuler/**"]

o

excludes += ["projecteuler/**"]

pero

excludes = ["**/projecteuler/**"]

para excluir un paquete *.projecteuler.*

y test {} en el nivel del proyecto, no anidado en jacocoTestReport

Answer 8

Here hay una solución para este problema en ANT. Esto se puede adaptar a gradle agregando lo siguiente en la tarea jacocoTestReport . Aunque esto no está realmente documentado por jacoco, parece ser la única forma de filtrar los resultados de la prueba por ahora.

afterEvaluate {
    classDirectories = files(classDirectories.files.collect {
        fileTree(dir: it, exclude: ''excluded/files/**'')
    })
}