coverage.gradle

import static groovy.json.JsonOutput.*

apply plugin: 'jacoco'

ext {
    limits = [
            'instruction': 95,
            'branch'     : 90,
            'line'       : 95,
            'complexity' : 95,
            'method'     : 100,
            'class'      : 100
    ]
}

test.finalizedBy jacocoTestReport

jacocoTestReport {
    reports {
        //XML required by coveralls and for the below coverage checks
        xml.enabled true
    }

    doLast {
        def report = file("${jacoco.reportsDir}/test/jacocoTestReport.xml")
        logger.lifecycle("Checking coverage results: ${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 = {
            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') }),
                'branch'     : percentage(counters.find { it.'@type'.equals('BRANCH') }),
                'line'       : percentage(counters.find { it.'@type'.equals('LINE') }),
                'complexity' : percentage(counters.find { it.'@type'.equals('COMPLEXITY') }),
                'method'     : percentage(counters.find { it.'@type'.equals('METHOD') }),
                'class'      : percentage(counters.find { it.'@type'.equals('CLASS') })
        ]


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

        codacyTestReport(results)


        if (failures) {
            logger.quiet("------------------ Code Coverage Failed -----------------------")
            failures.each {
                logger.quiet(it)
            }
            logger.quiet("---------------------------------------------------------------")
            throw new GradleException("Code coverage failed")
        } else{
            logger.quiet("Passed Code Coverage Checks")
            metrics.each {
                def limit = limits[it.key]
                logger.quiet("- ${it.key} coverage rate is: ${it.value}%, minimum is ${limit}%")
            }
        }
    }
}

def codacyPercentage(Node node) {
    def covered = node.'@covered' as Double
    def missed = node.'@missed' as Double
    (((covered / (covered + missed)) * 100).round(2)) as Integer
}

def codacyTestReport(Node report) {
    def codacy = [
            language: 'Java',
            total: codacyPercentage(report.counter.find { it.'@type'.equals('LINE') }),
            fileReports: codacyFileReports(report.package)]

    file("${jacoco.reportsDir}/test/codacy-coverage-report.json").write(prettyPrint(toJson(codacy)))
    logger.quiet("------------------ Generated Codacy Coverage Report -------------------")
}

def codacyFileReports(List<Node> packages) {
    packages.collectMany { packageNode ->
        String packageName = packageNode.'@name'
        packageNode.sourcefile.collect { sourceNode ->
            [
                    filename: packageName + '/' + sourceNode.'@name',
                    total: codacyPercentage(sourceNode.counter.find { it.'@type'.equals('LINE') }),
                    coverage: codacyLineReports(sourceNode.line)]
        }
    }
}

def codacyLineReports(List<Node> lines) {
    lines
            .findAll { (it.'@ci' as Integer) > 0 }
            .collectEntries { [(it.'@nr'): 1] }
}

check.dependsOn jacocoTestReport