coveragereporting.gradle

apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'jacoco'

jacoco {
    toolVersion '0.8.2'
}

// Excluded files
def fileFilter = ['**/R.class',
                  '**/R$*.class',
                  '**/*BR*.*',
                  '**/BuildConfig.*',
                  '**/Manifest*.*',
                  '**/*Test*.*',
                  'android/**/*.*',
                  '**/settings/*.*',
                  '**/SingleLiveEvent*',
                  '**/CustomTypefaceSpan*',
                  '**/*Adapter*',
                  '**/model/*.*',
                  '**/room/*.*',
                  '**/di/*.*',
                  '**/dropbox/*.*',
                  '**/reminders/*.*',
                  '**/backups/Dropbox/*.*',
                  '**/backups/UploadToCloudWorker*',
                  '**/*Binding*.*',
                  '**/*adapter*.*',
                  '**/*Activity*.*',
                  '**/AppLockFragment*',
                  '**/LocaleHelper*',
                  '**/TimelineFragment*',
                  '**/calendar/*.*',]

task jacocoTestReport(type: JacocoReport, dependsOn: 'testDebugUnitTest') {
    description = 'Generate JaCoCo coverage reports'
    group = 'Reporting'


    def mainSrc = android.sourceSets.main.java.srcDirs
    def debugTree = fileTree(
            dir: "$buildDir/intermediates/classes/debug",
            excludes: fileFilter
    ) + fileTree(
            dir: "$buildDir/tmp/kotlin-classes/debug",
            excludes: fileFilter
    )
    def testTree = fileTree(
            dir: "$buildDir",
            include: ['jacoco/testDebugUnitTest.exec', 'outputs/code-coverage/connected/*coverage.ec']
    )

    getSourceDirectories().setFrom(mainSrc)
    getClassDirectories().setFrom(debugTree)
    getExecutionData().setFrom(testTree)

    doFirst {
        files('build/intermediates/classes/debug').getFiles().each { file ->
            if (file.name.contains('$$')) {
                file.renameTo(file.path.replace('$$', '$'))
            }
        }
    }

    doLast {
        printReport("jacocoTestReport")
    }

    reports {
        xml.enabled = true
        html.enabled = true
    }
}

tasks.withType(Test) {
    jacoco.includeNoLocationClasses = true
    jacoco.excludes = ['jdk.internal.*']
}

def printReport(task) {
    def report = file("$buildDir/reports/${task}/${task}.xml")
    logger.lifecycle("Checking reports from ${report}")

    def parser = new XmlParser()
    parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
    parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)
    def results = parser.parse(report)

    def percentage = {
        if (it == null) {
            100
        } else {
            def covered = it.'@covered' as Double
            def missed = it.'@missed' as Double
            (covered / (covered + missed) * 100).round(2)
        }
    }

    def counters = results.counter
    def metrics = [:]
    metrics << [
            'instruction': percentage(counters.find { it.'@type'.equals('INSTRUCTION') }),
            'line'       : percentage(counters.find { it.'@type'.equals('LINE') }),
            'method'     : percentage(counters.find { it.'@type'.equals('METHOD') }),
            'class'      : percentage(counters.find { it.'@type'.equals('CLASS') })
    ]

    def failures = []
    def passes = []

    // Fail the task if the coverage is below these numbers
    def minTestCoverage = [
            'instruction': 80,
            'line'       : 80,
            'method'     : 80,
            'class'      : 80
    ]

    metrics.each {
        def limit = minTestCoverage[it.key]
        if (it.value < limit) {
            failures.add("- ${it.key} coverage rate is ${it.value}%, the minimum is ${limit}")
        } else {
            passes.add("- ${it.key} coverage rate is ${it.value}%")
        }
    }

    if (failures) {
        logger.log(LogLevel.ERROR, "\n\n CODE COVERAGE FAILED!!!")
        failures.forEach {
            logger.quiet(it)
        }
        passes.each {
            logger.quiet(it)
        }
        throw new GradleException("Code coverage failed")
    } else {
        logger.quiet("\n\n Code coverage passed!")
        passes.each {
            logger.quiet(it)
        }
    }

}