build.gradle

buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.github.jengelman.gradle.plugins:shadow:2.0.2"
        classpath "io.spring.gradle:dependency-management-plugin:1.0.5.RELEASE"
        classpath 'au.com.dius:pact-jvm-provider-gradle_2.12:3.6.2'
        classpath "org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.8.2"
    }
}

ext {
    axonVersion = '4.0.3'
    aspectjVersion = '1.9.1'
    junitVersion = '5.3.2'
    mockitoVersion = '2.24.5'
    projectVersion = '1.0.4'
    lombokVersion = '1.18.6'
}

subprojects { parentProject ->
    subprojects { project ->
        apply plugin: "java"
        apply plugin: "io.spring.dependency-management"
        apply plugin: 'checkstyle'
        apply plugin: 'jacoco'
        apply plugin: 'groovy'
        apply plugin: "com.github.kt3k.coveralls"

        sourceCompatibility = 1.8
        targetCompatibility = 1.8

        if(parentProject.name.equals('domain-services')) {
            apply plugin: "application"
            apply plugin: 'com.github.johnrengelman.shadow'
            apply plugin: 'au.com.dius.pact'

            shadowJar {
                mergeServiceFiles()
            }

            run.jvmArgs('-noverify', '-XX:TieredStopAtLevel=1')

            tasks.withType(JavaCompile) {
                options.encoding = "UTF-8"
                options.compilerArgs.add('-parameters')
            }
        }

        repositories {
            mavenLocal()
            jcenter()
        }

        dependencyManagement {
            imports {
                mavenBom "io.micronaut:micronaut-bom:$projectVersion"
            }
        }

        dependencies {
            compile("org.projectlombok:lombok:${lombokVersion}")
            annotationProcessor("org.projectlombok:lombok:${lombokVersion}")
            annotationProcessor "io.micronaut:micronaut-inject-java"
            annotationProcessor "io.micronaut:micronaut-validation"
            annotationProcessor "io.micronaut.configuration:micronaut-openapi"
            compile "io.micronaut.configuration:micronaut-openapi"
            compile "io.micronaut:micronaut-inject"
            compile "io.micronaut:micronaut-validation"
            compile "io.micronaut:micronaut-runtime"
            compile "io.micronaut:micronaut-http-client"
            compile "javax.annotation:javax.annotation-api"
            compile "io.micronaut:micronaut-http-server-netty"
            compileOnly "io.micronaut:micronaut-inject-java"
            compile "io.micronaut:micronaut-discovery-client"
            compile "io.swagger.core.v3:swagger-annotations"
            compile "io.micronaut.configuration:micronaut-hibernate-validator"
            if(parentProject.name.equals('domain-services')) {
                compile "au.com.dius:pact-jvm-consumer-junit5_2.12:3.6.2"
                runtime "ch.qos.logback:logback-classic:1.2.3"
            }
            runtime "io.micronaut:micronaut-management"
            testCompile "io.micronaut:micronaut-inject-java"
            testCompile "org.hamcrest:hamcrest-all:1.3"
            testCompile "org.assertj:assertj-core:3.12.1"
            testCompile 'io.rest-assured:rest-assured:3.3.0'
            testCompile "io.micronaut.test:micronaut-test-junit5:1.0.2"
            testCompile "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
            testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
            testRuntime "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
            testCompile "org.mockito:mockito-core:${mockitoVersion}"
            testCompile "org.mockito:mockito-junit-jupiter:${mockitoVersion}"
        }

        tasks.withType(Test) {
            maxParallelForks = 1 //Runtime.runtime.availableProcessors()
        }

        checkstyle {
            configFile = new File(rootDir, "checkstyles.xml")
        }

        checkstyleTest {
            source = fileTree('src/test') {
                excludes =
                        ['*.yml']
            }
        }

        jacoco {
            toolVersion = "0.8.2"
        }

        jacocoTestReport {
            additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
            sourceDirectories = files(sourceSets.main.allSource.srcDirs)
            classDirectories =  files(sourceSets.main.output)
            executionData = files(jacocoTestReport.executionData)
            reports {
                html.enabled = true
                xml.enabled = true
                csv.enabled = false
                html.destination = "./coverage/"
            }
            afterEvaluate {
                classDirectories = files(classDirectories.files.collect {
                    fileTree(dir: it,
                            exclude: [
                                    '**/configuration/**',
                                    '**/repositories/**',
                                    '**/events/**',
                                    '**/exceptions/**',
                                    '**/commands/**',
                                    '**/models/**',
                                    '**/Application'
                            ]
                    )
                })
            }
        }

        coveralls {
            sourceDirs = files(sourceSets.main.allSource.srcDirs).files.absolutePath
        }

        if(parentProject.name.equals('domain-services')) {
            task clearPactBroker() {
                doLast() {
                    def services = ['AccountCmd', 'AccountQuery', 'AccountTransactions', 'PeopleDetails']
                    for (service in services) {
                        println "http://localhost:8089/pacticipants/" + service
                        def p = ['curl', '-X', 'DELETE', "http://localhost:8089/pacticipants/" + service].
                                execute()
                        println p.text
                    }
                }
            }

            pact {
                serviceProviders {
                    // You can define as many as you need, but each must have a unique name
                    AccountCmd {
                        // All the provider properties are optional, and have sensible defaults (shown below)
                        protocol = 'http'
                        host = 'localhost'
                        port = 8082
                        path = '/'
                        if ('pactVerify' in gradle.startParameter.taskNames) {
                            hasPactsFromPactBroker('http://localhost:8089')
                        }
                    }

                    AccountQuery {
                        // All the provider properties are optional, and have sensible defaults (shown below)
                        protocol = 'http'
                        host = 'localhost'
                        port = 8084
                        path = '/'
                        if ('pactVerify' in gradle.startParameter.taskNames) {
                            hasPactsFromPactBroker('http://localhost:8089')
                        }
                    }

                    PeopleDetails {
                        // All the provider properties are optional, and have sensible defaults (shown below)
                        protocol = 'http'
                        host = 'localhost'
                        port = 8085
                        path = '/'
                        if ('pactVerify' in gradle.startParameter.taskNames) {
                            hasPactsFromPactBroker('http://localhost:8089')
                        }
                    }

                    AccountTransactions {
                        // All the provider properties are optional, and have sensible defaults (shown below)
                        protocol = 'http'
                        host = 'localhost'
                        port = 8086
                        path = '/'
                        if ('pactVerify' in gradle.startParameter.taskNames) {
                            hasPactsFromPactBroker('http://localhost:8089')
                        }
                    }
                }

                publish {
                    def folder = new File('./tests/pact-tests')
                    if (folder.exists()) {
                        pactDirectory = './tests/pact-tests'
                    } else if ((new File('../tests/pact-tests')).exists()) {
                        pactDirectory = '../tests/pact-tests'
                    } else {
                        pactDirectory = '../../tests/pact-tests'
                    }
                    pactBrokerUrl = 'http://localhost:8089'
                }
            }
        }

        test {
            useJUnitPlatform()
            systemProperties['pact.rootDir'] = "../../tests/pact-tests"
        }

        task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
            dependsOn = subprojects.test
            additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)
            sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
            classDirectories =  files(subprojects.sourceSets.main.output)
            executionData = files(subprojects.jacocoTestReport.executionData)
            reports {
                html.enabled = true
                xml.enabled = true
                csv.enabled = false
            }
        }

        //test.finalizedBy(jacocoTestCoverageVerification)
    }
}