Cobertura de código jacoco en Android Studio con sabores.

gradle code-coverage

Question

He estado tratando de ejecutar la cobertura de prueba de Jacoco por un momento de calma. He intentado varias posibles soluciones reportadas en estos temas:

Cobertura de código de prueba de Android con JaCoCo Gradle plugin

¿Cómo obtengo un informe de cobertura de jacoco con Android gradle plugin 0.10.0 o superior?

Estoy ejecutando las pruebas en un dispositivo emulado usando genymotion. Esto es lo que agregué a build.gradle:

apply plugin: ''jacoco''

android{       
    jacoco {
        version "0.7.1.201405082137"
    }        
    buildTypes{
        debug{
                    testCoverageEnabled = true
        }
    }
}

jacoco {
    toolVersion "0.7.1.201405082137"
}

Para ejecutarlo uso algo como

./gradlew clean
./gradlew createFLAVOR_NAMEDebugCoverageReport

Los archivos / carpetas generados relevantes son:

/build/intermediates/coverage-instrumented-classes
/build/intermediates/jacoco
/build/outputs/code-coverage/connected/flavors/MyFlavor/coverage.ec

Sin embargo, no hay nada en @ build / reports / jacoco / test / html / index.html ni en ningún informe de cobertura de página / código html @ / build / output.

También he intentado crear una tarea dedicada para crear un informe de cobertura:

def coverageSourceDirs = [
    ''src/main/java'',
]

task jacocoTestReport(type: JacocoReport, dependsOn: "connectedAndroidTestFLAVOR_NAMEDebug") {
    group = "Reporting"
    description = "Generate Jacoco coverage reports after running tests."
    reports {
        xml.enabled = true
        html.enabled = true
    }
    classDirectories = fileTree(
        dir: ''./build/intermediates/classes/debug'',
        excludes: [''**/R*.class'',
                   ''**/*$InjectAdapter.class'',
                   ''**/*$ModuleAdapter.class'',
                   ''**/*$ViewInjector*.class''
        ])
    sourceDirectories = files(coverageSourceDirs)
    executionData = files("$buildDir/jacoco/connectedAndroidTestMyFlavorDebug.exec")
    // Bit hacky but fixes https://code.google.com/p/android/issues/detail?id=69174.
    // We iterate through the compiled .class tree and rename $$ to $.
    doFirst {
       new File("$buildDir/intermediates/classes/").eachFileRecurse { file ->
            if (file.name.contains(''$$'')) {
                file.renameTo(file.path.replace(''$$'', ''$''))
            }
        }
    }
}

Luego ./gradlew clean y ./gradlew jacocoTestReport . La salida es la misma que la anterior, por lo tanto, no hay página html con informe de cobertura o cualquier otro archivo de cobertura.

Actualmente estoy usando Android Studio v1.0.2 con la última versión de Gradle. Soy bastante nuevo en Gradle, por lo que es posible que me esté perdiendo algo básico aquí.

Gracias

Answer 1

Después de pasar todo el día persiguiendo este problema, descubrí cuál es el problema. Al contrario de los ejemplos, he visto que el archivo generado por la compilación testDebug no es el archivo .exec @ $ buildDir / jacoco / testDebug.exec .

Con mi versión de gradle y estudio, el archivo generado es .ec @ build / output / code-cover / connected / flavours / myFlavor / coverage.ec

No encontré ninguna información relevante relacionada con esto. Puede ser un cambio reciente, sin embargo, al crear una tarea personalizada de JacocoReport y cambiar la variable de datos de ejecución en consecuencia, he resuelto el problema. Aquí está mi implementación:

task jacocoTestReport(type: JacocoReport) {

  def coverageSourceDirs = [
        ''src/main/java''
  ]

  group = "Reporting"
  description = "Generates Jacoco coverage reports"
  reports {
      xml{
          enabled = true
          destination "${buildDir}/reports/jacoco/jacoco.xml"
      }
      csv.enabled false
      html{
          enabled true
          destination "${buildDir}/jacocoHtml"
      }
  }

  classDirectories = fileTree(
          dir: ''build/intermediates/classes'',
          excludes: [''**/R.class'',
                     ''**/R$*.class'',
                     ''**/BuildConfig.*'',
                     ''**/Manifest*.*'',
                     ''**/*Activity*.*'',
                     ''**/*Fragment*.*''
          ]
  )

  sourceDirectories = files(coverageSourceDirs)
  additionalSourceDirs = files(coverageSourceDirs)
  executionData = files(''build/outputs/code-coverage/connected/flavors/smartcompanion/coverage.ec'')
}

Answer 2

Informe de cobertura de prueba usando Jacoco con sabores de Android:

Consideremos que tienes sabores llamados "gratis" y "pagados"

• Paso 1 : cree el archivo jacoco.gradle en el directorio de su módulo de proyectos (aplicación predeterminada) donde exista build.gradle, debe estar al lado del archivo build.gradle. estructura de directorios como se muestra a continuación

  app> jacoco.gradle

• Paso 2 : pegue el código siguiente en el archivo que creamos en el Paso 1, el código tiene comentarios que se explican por sí mismos para comprender.

apply plugin: ''jacoco''

jacoco {
    toolVersion = "0.7.5.201505241946"
}
project.afterEvaluate {
    // Grab all build types and product flavors
    def buildTypes = android.buildTypes.collect { type ->
        type.name
    }
    def productFlavors = android.productFlavors.collect { flavor ->
        flavor.name
    }
    // When no product flavors defined, use empty
    if (!productFlavors) productFlavors.add('''')

    //iterate over the flavors

    productFlavors.each {

        productFlavorName ->
//iterate over build types like debug,release,prod etc.
        buildTypes.each {

            buildTypeName ->
                //sourceName — e.g. freeDebug ,sourcePath — e.g. free/debug
            def sourceName, sourcePath
            if (!productFlavorName) {
                sourceName = sourcePath = "${buildTypeName}"
            } else {
                sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
                sourcePath = "${productFlavorName}/${buildTypeName}"
            }
                // testTaskName —  e.g. testFreeDebugtest task that the coverage task depends on,
            def testTaskName = "test${sourceName.capitalize()}UnitTest"
            // Create coverage task of form ''testFlavorTypeCoverage'' depending on ''testFlavorTypeUnitTest''
            task "${testTaskName}Coverage" (type:JacocoReport, dependsOn: "$testTaskName") {
                group = "Reporting"
                description = "Generate Jacoco coverage reports on the ${sourceName.capitalize()} build."
                classDirectories = fileTree(
                        dir: "${project.buildDir}/intermediates/classes/${sourcePath}",
                        excludes: [
                                ''**/R.class'',
                                ''**/R$*.class'',
                                ''**/*$ViewInjector*.*'',
                                ''**/*$ViewBinder*.*'',
                                ''**/BuildConfig.*'',
                                ''**/Manifest*.*''
                        ]
                )
                def coverageSourceDirs = [
                        "src/main/java",
                        "src/$productFlavorName/java",
                        "src/$buildTypeName/java"
                ]
                additionalSourceDirs = files(coverageSourceDirs)
                sourceDirectories = files(coverageSourceDirs)
                executionData = files("${project.buildDir}/jacoco/${testTaskName}.exec")
                reports {
                    //enables and disable the type of file you need
                    xml.enabled = false
                    html.enabled = true
                }
            }
        }
    }
}

• Paso 3: ejecuta los siguientes comandos en el terminal de Android Studio para crear la aplicación

  ./gradlew limpio ensamblar

• Paso 4: en compilación exitosa, ejecute el comando siguiente para generar el informe de prueba (cambie la cadena "testFreeDebugUnitTestCoverage" por su tipo particular de construcción / sabor, por ejemplo, el comando para la versión de pago será ./gradlew testPaidDebugUnitTestCoverage)

  ./gradlew testFreeDebugUnitTestCoverage

• Paso 5:

Debería dar un mensaje de éxito en la terminal, ahora vaya al directorio

>app > build > reports >jacoco >${testName} >look for html or xml file report file

• Paso 6: Ahora puede abrir y ver el archivo de cobertura de prueba html en el navegador

La mejor de las suertes !!!