build.gradle

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

plugins {
    id 'com.jfrog.bintray' version '1.8.4'
    id 'com.github.johnrengelman.shadow' version '2.0.2'
    id 'com.github.kt3k.coveralls' version '2.8.2'
    id 'com.marklogic.ml-gradle' version '3.12.0'
    id 'io.github.ddimtirov.codacy' version '0.1.0'
    id 'org.sonarqube' version '2.6.2'
    id 'eclipse'
    id 'idea'
    id 'jacoco'
    id 'java'
    id 'maven-publish'
}

ext {
    externalsortinginjavaVersion = '0.2.5'

    // we don't need a REST server, only an XCC server
    mlAppDeployer.getCommands().remove(mlAppDeployer.getCommand('DeployRestApiServersCommand'))
    mlAppConfig {
        name = project.name
        customTokens.put('%%XDBC_PORT%%', '8223')
        createTriggersDatabase = false
    }
}

sourceCompatibility = '1.8'
targetCompatibility = '1.8'

repositories {
    jcenter()
    flatDir {
        dirs 'src/test/resources/'
    }
    //required for codacyUpload task
    maven { url "http://dl.bintray.com/typesafe/maven-releases" }
}

sourceSets {
    integrationTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/test/java')
        }
        resources.srcDir file('src/test/resources')
    }
    performanceTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/test/java')
        }
        resources.srcDir file('src/test/resources')
    }
}

configurations {
    shadow
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime

    performanceTestCompile.extendsFrom testCompile
    performanceTestRuntime.extendsFrom testRuntime
}

dependencies {
    compile 'com.marklogic:marklogic-xcc:9.0.9'
    //we bundle the externalsortinginjava classes with the corb distro as a fat jar
    compileOnly "com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"
    shadow "com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"
    testCompile "com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"
    testCompile group: 'junit', name: 'junit', version: '4.12'
    testCompile 'org.jasypt:jasypt:1.9.2'
    testCompile 'com.github.stefanbirkner:system-rules:1.17.1' //facilitates tests for methods that invoke System.exit
    testCompile 'org.mockito:mockito-all:1.10.19'
}

test {
    testLogging {
        events TestLogEvent.STARTED,TestLogEvent.PASSED
    }
    //we will run Integration and Performance tests in separate tasks
    exclude '**/*IT.class'
    exclude '**/*PT.class'
}

//disabling, because we want to incorporate externalsortingjava in uber jar and use as the artifact
jar.enabled = false
shadowJar {
    configurations = [project.configurations.compile, project.configurations.shadow]
    dependencies {
        include(dependency("com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"))
    }
    //generate same name as the jar task would
    archiveName = "${baseName}-${version}.${extension}"
    manifest {
        attributes 'Application-Version': project.version
        attributes 'Build-date' : new Date()
        attributes 'Main-Class' : 'com.marklogic.developer.corb.Manager'

        attributes 'Name': 'com/marklogic/developer/corb/'
        attributes 'Specification-Title' : 'corb'
        attributes 'Specification-Version' : project.version
        attributes 'Implementation-Title' : project.name
        //Manager class reads the version for usage messages
        attributes 'Implementation-Version' : project.version
    }
}

build.dependsOn(shadowJar)

task sourcesJar(type: Jar, dependsOn: classes) {
    description = "Create a JAR of source files; required by bintray for publishing"
    classifier 'sources'
    from sourceSets.main.allJava
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier = 'javadoc'
    from 'build/docs/javadoc'
}

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

task integrationTest(type: Test, dependsOn: test) {
    testClassesDir = sourceSets.integrationTest.output.classesDir
    classpath = sourceSets.integrationTest.runtimeClasspath
    filter {
        //include all integration tests
        includeTestsMatching "*IT"
    }
    testLogging {
        events TestLogEvent.STARTED,TestLogEvent.PASSED
    }
    //If you want to ensure that integration tests are run every time when you invoke
    //this task, uncomment the following line.
    //outputs.upToDateWhen { false }
    jacoco {
        //coverage report will include both unit and integration tests
        append = true
        destinationFile = file("$buildDir/jacoco/test.exec")
    }
    //generate the Jacoco report
    finalizedBy { tasks.integrationTestReport }
}

task integrationTestReport(type: JacocoReport) {
    sourceSets sourceSets.main
    executionData integrationTest
}

task performanceTest(type: Test) {
    testClassesDir = sourceSets.performanceTest.output.classesDir
    classpath = sourceSets.performanceTest.runtimeClasspath
    filter {
        //include all performance tests
        includeTestsMatching "*PT"
    }
    testLogging {
        events TestLogEvent.STARTED,TestLogEvent.PASSED
    }

    //If you want to ensure that performance tests are run every time when you invoke
    //this task, uncomment the following line.
    outputs.upToDateWhen { false }
}

check.dependsOn jacocoTestReport
//Ensure that the check task fails the build if there are failing integration tests.
check.dependsOn integrationTest
//Ensure that our unit tests are run before our integration tests
integrationTest.mustRunAfter test
integrationTest.onlyIf { !project.hasProperty('skipIntegrationTest') }
//Ensure that the check task fails the build if there are failing performance tests.
//check.dependsOn performanceTest
//Ensure that our unit tests are run before our performance tests
performanceTest.mustRunAfter integrationTest
performanceTest.onlyIf { !project.hasProperty('skipPerformanceTest') }

tasks.withType(Test) {
    reports.html.destination = file("${reporting.baseDir}/${name}")
    testLogging {
        // set options for log level LIFECYCLE
        events TestLogEvent.PASSED,
               TestLogEvent.FAILED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_OUT
        showExceptions true
        exceptionFormat TestExceptionFormat.SHORT
        showCauses true
        showStackTraces true

        // set options for log level DEBUG and INFO
        debug {
            events TestLogEvent.PASSED,
                   TestLogEvent.FAILED,
                   TestLogEvent.SKIPPED,
                   TestLogEvent.STANDARD_OUT,
                   TestLogEvent.STANDARD_ERROR
            exceptionFormat TestExceptionFormat.FULL
        }
        info.events = debug.events
        info.exceptionFormat = debug.exceptionFormat

        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
                def startItem = '|  ', endItem = '  |'
                def repeatLength = startItem.length() + output.length() + endItem.length()
                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
            }
        }
    }
}

tasks.coveralls {
    dependsOn 'check'
}

publishing {
    publications {
        mainJava(MavenPublication) {
            from components.java
            artifact sourcesJar
            artifact javadocJar
            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST
                    name "corb"
                    url project.websiteUrl
                    scm {
                        url project.vcsUrl
                    }
                    issueManagement {
                        system "GitHub Issues"
                        url project.issueTrackerUrl
                    }
                    licenses {
                        license {
                            name "The Apache Software License, Version 2.0"
                            url "http://www.apache.org/licenses/LICENSE-2.0.txt"
                            distribution "repo"
                        }
                    }
                    description 'CoRB is a Java tool designed for bulk content-reprocessing of documents stored in MarkLogic.'
                    developers {
                        developer {
                            name "Bhagat Bandlamudi"
                            email "bhagat.bandlamudi@marklogic.com"
                            organization "MarkLogic"
                        }
                        developer {
                            name "Mads Hansen"
                            email "mads.hansen@marklogic.com"
                            organization "MarkLogic"
                        }
                    }
                }
            }
        }
    }
}

/*
 * In order to publish to bintray, you need an account. Once you have that account, set myBintrayUser and myBintrayKey
 * to your username and key. You can do that in the project gradle.properties file, but it's better to do so in your
 * ~/.gradle/gradle.properties file. Once you do that, you can run "gradle -i bintray" to publish it to bintray.
 */
if (project.hasProperty("myBintrayUser")) {
    bintray {
        user = myBintrayUser
        key = myBintrayKey
        publications = ['mainJava']
        //dryRun = true
        pkg {
            repo = 'maven'
            name = project.name
            licenses = ['Apache-2.0']
            userOrg = 'marklogic'
            websiteUrl = project.websiteUrl
            issueTrackerUrl = project.issueTrackerUrl
            vcsUrl = project.vcsUrl
            githubRepo = 'marklogic-community/corb2'
            githubReleaseNotesFile = 'README.md'
            version {
                name = project.version
                released = new Date()
            }
        }
    }
}