使用Gradle运行所有子项目测试

Question

I have a multi-module android project with the structure:

:a
:b
  :c
  :d
    :e

I'm trying to run a jacoco report on module :b so that it runs on :b, :c, :d, and :e without running :a. I want all of the xml reports to be in a common folder with names of their project.xml (egbxml, c.xml, etc.) I have a pretty standard jacoco setup

task jacocoTestReport(type: JacocoReport, dependsOn: ['testDebugUnitTest', 'createDebugCoverageReport']) {

    reports {
        xml.enabled = true
        xml.destination = file(allTestCoverageDir + project.name + ".xml")
        html.enabled = true
    }

    def fileFilter = [
            '**/R.class',
            '**/R$*.class',
            '**/BuildConfig.*',
            '**/Manifest*.*',
            '**/*Test*.*',
            'android/**/*.*',

            //Dagger 2
            '**/*Dagger*Component*.*',
            '**/*Module.*',
            '**/*Module$*.*',
            '**/*MembersInjector*.*',
            '**/*_Factory*.*',
            '**/*Provide*Factory*.*',
    ]

    def kotlinDebug = [fileTree(dir: "${project.buildDir}/tmp/kotlin-classes/debug", excludes: fileFilter)]
    def mainSrc = files([
            "$project.projectDir/src/main/java",
            "$project.projectDir/src/main/kotlin"
    ])

    sourceDirectories = files([mainSrc])
    classDirectories = files(kotlinDebug)
    executionData = fileTree(dir: project.buildDir, includes: [
            'jacoco/testDebugUnitTest.exec', 'outputs/code-coverage/connected/*coverage.ec'
    ])
}

But when I try to loop through subprojects in a doLast block, the doLast block never runs and trying to access subprojects before that also shows that :a has no subprojects.

Edit I am able to run these for each sub project with ./gradlew b:jacocoTestReport or ./gradlew c:jacocoTestReport and all the reports and in a folder with the correct names. But as my project grows I don't want to have to run dozens of commands (one for each module) I want a single command ./gradlew b:jacocoTestReport (or something similar) which runs for b and it's subtree

Answer 1

As far as I understand at the moment you're using allprojects {} to configure all of the sub projects. Although this has been the canonical to configure a group of projects in the past, it is now discouraged. Furthermore projects should use publications to interface with each other instead of copying files across project boundaries. So you need to do two things:

1. Instead of configuring the sub projects from the root root project, you should create a plugin to configure jacoco and create configuration that will hold the reports.

To do this, create a pre-compiled script plugin in your project. The idea is to have a kotlin build script in the buildSrc project and create a Gradle plugin from that file on the fly. So you should move the logic that configures jacoco to the file buildSrc/src/main/kotlin/jacoco-conventions.gradle.kts :

plugins {
    jacoco
}

val jacocoTestReport by tasks.getting(JacocoReport::class) {
  // jacoco configuration 
}

configurations.create("jacocoReports") {
    isCanBeResolved = false
    isCanBeConsumed = true
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class, "jacocoReports"))
    }
    outgoing.artifact(jacocoTestReport.reports.xml.destination) {
        builtBy(jacocoTestReport)
    }
}

The last part creates a new configuration in the project the pre-compiled script plugin is applied to. This configuration uses the xml destination file which is builtBy the jacoco report task as an outgoing artifact. The important part here is the USAGE_ATTRIBUTE because we will need this later on to consume the files.

The precompiled script plugin can now be applied in the projects where you want to gather jacoco metrics by:

// for example in c/build.gradle.kts
plugins {
  `jacoco-conventions`
}

Now you have configured the sub projects to put the Jacoco xml reports into configurations with usage attribute jacocoReports .

2. In the root project create a task that copies the report from the configuration.

To do this we need to setup a configuration that consumes the jacocoReports variants and then depend on the variants of the sub projects:

// main build file
val jacocoReports by configurations.creating {
    isCanBeResolved = true
    isCanBeConsumed = false
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class, "jacocoReports"))
    }
}

dependencies {
    jacocoReports(project(":b:c"))
    jacocoReports(project(":b:d:e"))
    // other jacocoReports you want to consume
}

tasks.register<Copy>("aggregateJacocoReports") {
    from(jacocoReports)
    into(file("$buildDir/jacoco"))
}

As you can see, the jacocoReports configuration has the same usage attribute, so it can be used to resolve files that are in configurations with the same attribute. Then we need to define which project reports we want to consume. This is cone by defining project dependencies using the jacocoReports configuration. The last step is a simple copy task that copies the files into the build directory of the root project. So now when you call ./gradlew aggregateJacocoReports this task resolves all the files from the jacocoReports configuration, which in turn will create the jacoco report for all projects that are the root project has a dependency on.

Why is this better than cross configuration? If projects are not entangled by cross configuration and by tasks that copy stuff between projects, gradle can more efficiently schedule and parallelize the work that has to be done.

I have a created a minimal example that should help you to setup your project this way: https://github.com/britter/gradle-jacoco-aggregate . I have removed the android specific configuration to keep it simple, but I'm sure you will figure it out.