build.gradle

import com.lesfurets.gradle.*

plugins {
    id "com.jfrog.artifactory" version "4.11.0"
    id 'groovy'
    id 'maven-publish'
    id 'java'
    id 'jacoco'
}

repositories {
  mavenCentral()
  jcenter()
}

group = "com.lesfurets"
archivesBaseName = "jenkins-pipeline-unit"
version = "1.3-SNAPSHOT"

sourceCompatibility = 1.8
targetCompatibility = 1.8

// Grape configuration is used to test @Grape annotation in unit tests using grapeConfig.xml
configurations {
    grape { // Note our simple use case does not use or support transitive dependencies
        transitive = false
    }
}

dependencies {
    compile     group: 'org.codehaus.groovy',   name: 'groovy-all',     version: '2.4.6'
    compile     group: 'com.cloudbees',         name: 'groovy-cps',     version: '1.12'
    compile     group: 'commons-io',            name: 'commons-io',     version: '2.5'
    compile     group: 'org.apache.ivy',        name: 'ivy',            version: '2.4.0'
    compile     group: 'org.assertj',           name: 'assertj-core',   version: '3.4.1'
    compile     group: 'org.apache.commons',    name: 'commons-lang3',  version: '3.5'
    testCompile group: 'org.assertj',           name: 'assertj-core',   version: '3.4.1'
    testCompile group: 'junit',                 name: 'junit',          version: '4.11'
    grape       group: 'org.apache.commons',    name: 'commons-math3',  version: '3.4.1'
}

// Get external properties from file
if (project.hasProperty('extProps')) {
    def props = new Properties()
    file("$extProps").withInputStream { props.load(it) }
    props.stringPropertyNames().forEach {
        ext."$it" = props.getProperty(it)
    }
}

defaultTasks 'test'

task javadocJar(type: Jar) {
    classifier = 'javadoc'
    from groovydoc
}

task sourcesJar(type: Jar) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

// Copy the resolved grapes configuration to a maven2 like directory structure (no transitive dependencies)
task copyGrapesDependencies(type: CopyDependenciesToMavenTreeTask) {
    configuration = configurations.grape
    outputDir = "$buildDir/grapes"
}

test.dependsOn copyGrapesDependencies

test {
    systemProperty "grape.config", "$projectDir/grapeConfig.xml"
    systemProperty "grape.home", file("$buildDir/grapes").toURI()
    // Settings for debugging @Grape() resolution in test cases
    //systemProperty "groovy.grape.report.downloads", "true"
    //systemProperty "ivy.message.logger.level", "4"
    testLogging {
        events "PASSED", "FAILED", "SKIPPED"
    }
}

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


publishing {
    publications {
        maven(MavenPublication) {
            from components.java
            artifact tasks.sourcesJar
            artifact tasks.javadocJar
            pom {
                artifactId = "$project.archivesBaseName"
                packaging = 'jar'
                description = 'Jenkins Pipeline Unit testing framework'
                url = 'https://github.com/jenkinsci/JenkinsPipelineUnit'

                scm {
                    url =  'https://github.com/jenkinsci/JenkinsPipelineUnit'
                    connection = 'scm:git:git://github.com/jenkinsci/JenkinsPipelineUnit.git'
                    developerConnection = 'scm:git:git@github.com/jenkinsci/JenkinsPipelineUnit.git'
                }

                licenses {
                    license {
                        name = 'MIT License'
                        url = 'http://www.opensource.org/licenses/mit-license.php'
                        distribution = 'repo'
                    }
                }

                developers {
                    developer {
                        id = 'ozangunalp'
                        name = 'Ozan Gunalp'
                        email = 'ozangunalp@gmail.com'
                        url = 'https://github.com/ozangunalp'
                        organization = 'lesfurets.com'
                        organizationUrl = 'https://github.com/lesfurets'
                    }
                    developer {
                        id = 'EQuincerot'
                        name = 'Emmanuel Quincerot'
                        url = 'https://github.com/EQuincerot'
                        organization = 'lesfurets.com'
                        organizationUrl = 'https://github.com/lesfurets'
                    }
                    developer {
                        name = 'Thomas du Boÿs'
                        url = 'https://github.com/Skool'
                        id = 'Skool'
                        organization = 'lesfurets.com'
                        organizationUrl = 'https://github.com/lesfurets'
                    }
                }
            }
        }
    }
}

artifactory {
    contextUrl = 'https://repo.jenkins-ci.org'
    publish {
        repository {
            repoKey = project.version.toString().endsWith('-SNAPSHOT') ? 'snapshots' : 'releases'
            username = "${artifactory_user}" // The publisher user name
            password = "${artifactory_password}" // The publisher password
        }
        defaults {
            // Reference to Gradle publications defined in the build script.
            // This is how we tell the Artifactory Plugin which artifacts should be
            // published to Artifactory.
            publications('maven')
            publishArtifacts = true
            // Properties to be attached to the published artifacts.
            properties = ['qa.level': 'basic', 'dev.team' : 'core']
            // Publish generated POM files to Artifactory (true by default)
            publishPom = true
        }
    }
}

// Deploy tasks
//closeAndReleaseRepository.mustRunAfter(uploadArtifacts)
//closeRepository.enabled = !project.version.toString().endsWith('-SNAPSHOT')
//releaseRepository.enabled = !project.version.toString().endsWith('-SNAPSHOT')

task verify(dependsOn: build)
task deploy(dependsOn: [build, artifactoryDeploy])

// Release commits and tag
task writeVersion(type: SetVersionTask)
task commitRelease(type: GitCommitTask, dependsOn: [writeVersion])
task tagVersion(type: GitTagTask, dependsOn: [writeVersion, commitRelease])
task writeNextSnapshot(type: SetNextSnapshotVersionTask)
task commitNextDevVersion(type: GitCommitTask, dependsOn: [writeNextSnapshot]) {
    message = "Next dev version"
}

task release(dependsOn: [writeVersion, tagVersion, commitRelease])
task nextDevVersion(dependsOn: [writeNextSnapshot, commitNextDevVersion])