build.gradle

import java.awt.Desktop
import java.lang.management.ManagementFactory
import java.lang.management.RuntimeMXBean
import java.nio.file.Paths
import java.util.concurrent.TimeUnit

buildscript {
    repositories {
        mavenLocal()
        maven {url 'https://jenkins.cs.ox.ac.uk/artifactory/plugins-snapshot'}
        maven {url 'https://jenkins.cs.ox.ac.uk/artifactory/plugins-release'}

    }
    dependencies {
        classpath "uk.ac.ox.softeng.maurodatamapper.gradle:mdm-gradle-plugin:$mdmGradlePluginVersion"
        classpath "uk.ac.ox.softeng.maurodatamapper.gradle:mdm-gradle-plugin:$mdmGradlePluginVersion"
    }
    configurations.all {
        // check for updates every build
        resolutionStrategy.cacheChangingModulesFor 0, TimeUnit.SECONDS
    }
}

plugins {
    id 'maven-publish'
    id "org.sonarqube" version "3.3"
    // The springboot plugin is loaded in by grails and if the version of the plugin isnt right it will override all versions of imported spring boot dependencies
    // Therefore we can define it here (but not apply it to the root) and then ALL subprojects will use this version rather than another version
    id 'org.springframework.boot' version "${springBootVersion}" apply false
}

apply plugin: 'ox.softeng.ox-brc-base'

task unitTest() {
    group 'testing'
    description = 'Catch task for unit test'
}

task integrationTest() {
    group 'testing'
    description = 'Catch task for integration test'
    mustRunAfter unitTest
}

task jacocoRootReport() {
    group 'reporting'
    description = 'Catch task for all jacoco root report'
    mustRunAfter unitTest, integrationTest
}

task staticCodeAnalysis() {
    group 'reporting'
    description = 'Catch task for all SCA tasks'
    mustRunAfter unitTest, integrationTest, jacocoRootReport
}

check {
    dependsOn unitTest, integrationTest, jacocoRootReport, staticCodeAnalysis
}

task('sysProps') {
    group 'help'
    doLast {
        logger.quiet('{}', System.properties.collect {"${it.key}:${it.value}"}.sort().join('\n'))
    }
}

task('jvmArgs') {
    group 'help'
    doLast {
        RuntimeMXBean runtimeMxBean2 = ManagementFactory.getRuntimeMXBean()
        logger.quiet('{}', runtimeMxBean2.getInputArguments().join('\n'))
    }
}

task('jenkinsClean') {
    group 'clean'
    delete 'build'
}

logger.quiet(
    "Available processors ${Runtime.runtime.availableProcessors()}. Max Unit Test Parallel Forks " +
    "${Runtime.runtime.availableProcessors().intdiv(2) ?: 1}")

task rootTestReport(type: TestReport) {
    group = 'reporting'
    destinationDir = file("${buildDir}/reports/tests")
    testResultDirs = files("${buildDir}/test-results")
    FileCollection testResultContentDir = files("${buildDir}/test-results")
    outputs.upToDateWhen {false}

    doFirst {
        (testResultContentDir.getAsFileTree().visit {FileVisitDetails details ->
            if (details.directory && details.name == 'binary') {
                logger.info("Reporting on ${details.path}")
                reportOn files(details.file)
            }
        })
    }
    doLast {
        if (Desktop.isDesktopSupported()) {
            Desktop.desktop.open(Paths.get("${buildDir}/reports/tests/index.html").toFile())
        } else {
            logger.error("File opening not supported by JVM, use native OS command")
        }
    }
}

tasks.register('outputRuntimeArgs') {
    doLast {
        RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean()
        List<String> arguments = runtimeMxBean.getInputArguments()

        logger.warn("Running with JVM args : {}", arguments.size())
        Map<String, String> map = arguments.collectEntries {arg ->
            arg.split('=').toList()
        }.sort() as Map<String, String>

        map.each {k, v ->
            if (v) logger.quiet('{}={}', k, v)
            else logger.quiet('{}', k)
        }
    }
}

tasks.register('outputIntegrationTestShell') {
    doLast {
        StringBuilder sb = new StringBuilder('./gradlew --build-cache -Dgradle.integrationTest=true \\')
        subprojects.each {
            if (it.name != 'mdm-testing-functional' &&
                it.file('src/integration-test').exists()) sb.append('\n   ').append(it.path).append(':integrationTest \\')
        }
        logger.quiet '{}', sb.toString()
    }
}

tasks.register('outputFunctionalTestShell') {
    doLast {
        StringBuilder sb = new StringBuilder('./gradlew --build-cache -Dgradle.functionalTest=true \\')
        subprojects.each {
            if (it.name != 'mdm-testing-functional' &&
                it.file('src/integration-test').exists()) sb.append('\n   ').append(it.path).append(':integrationTest \\')
        }
        logger.quiet '{}', sb.toString()
    }
}

tasks.register('outputE2ETestShell') {
    doLast {
        file('mdm-testing-functional/src/integration-test/groovy/uk/ac/ox/softeng/maurodatamapper/testing/functional').listFiles().each {f ->
            logger.quiet './gradlew --build-cache -Dgradle.test.package={} :mdm-testing-functional:integrationTest', f.name
        }
    }
}

subprojects {

    project.ext['mdmCoreVersion'] = version

    tasks.register("bomProperties") {
        group = 'Introspection'
        description = 'Print properties from all BOMs'
        doLast {
            if (project.hasProperty('dependencyManagement')) {
                Map imported = dependencyManagement.importedProperties
                logger.quiet 'Project :: {}\nproperty,version,overriden_version\n{}', project.name, imported.collect {k, v ->
                    def projProp = project.hasProperty(k) ? project.getProperty(k) : project.hasProperty(k - '.version') ? project.getProperty(k - '.version') : null
                    "$k,$v,${projProp ?: ''}"
                }.sort().join('\n')
            }
        }
    }

    tasks.register('copyTestResultsToRoot', Copy) {
        from file("${project.buildDir}/test-results")
        into file("${rootProject.buildDir}/test-results/${project.name}")
        doFirst {
            logger.quiet("Copying ${file("${project.buildDir}/test-results")} to ${file("${rootProject.buildDir}/test-results/${project.name}")}")
        }
        rootProject.rootTestReport.dependsOn it
    }

    afterEvaluate {

        // This doubles down on making sure the imported and overridden properties from mdm-bom are properly enforced on all sub projects
        if (project.name != 'mdm-bom') {
            project.getRootProject().findProject(':mdm-bom').ext['controlledProperties'].each {k, v ->
                project.ext[k] = v
            }
        }

        // Dont bother with mergeTestReports if running in jenkins
        if (project.tasks.findByName('mergeTestReports')) {
            project.tasks.findByName('mergeTestReports').onlyIf {
                !System.getenv().containsKey('JENKINS')
            }
        }

        /*
        To make the following work, tests or classes should be marked with the jupiter annotation @Tag
         */
        if (project.tasks.findByName('integrationTest')) {
            FileCollection nonParallelTestFiles = findNonParallelTestFiles(project)
            if (project.ext.parallelTestingOnly) {
                if (project.ext.itTestsAvailable) logger.log(LogLevel.WARN, '<<>> Running integration tests in parallel mode <<>>')
                project.integrationTest {
                    maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
                    useJUnitPlatform {
                        // TODO Once spock handles jupiter tags then we can use this and remove the filter
                        //                        excludeTags 'non-parallel'
                    }
                    filter {
                        nonParallelTestFiles.each {f ->
                            logger.log(LogLevel.WARN, 'Ignoring {}', f.name - '.groovy')
                            excludeTestsMatching("*${f.name - '.groovy'}")
                        }
                    }
                    binaryResultsDirectory.set(project.file("${project.testResultsDir}/parallelIntegrationTest/binary"))
                    reports {
                        junitXml.getOutputLocation().set project.file("${project.testResultsDir}/parallelIntegrationTest")
                    }
                    jacoco {
                        destinationFile = project.file("${project.buildDir}/jacoco/parallelIntegrationTest.exec")
                    }
                }
                project.mergeTestReports.reportOn(project.file("${project.testResultsDir}/parallelIntegrationTest/binary"))
            } else if (project.ext.nonParallelTestingOnly) {
                if (!nonParallelTestFiles.isEmpty()) logger.log(LogLevel.WARN, '<<>> Running integration tests in non-parallel mode <<>>')
                project.integrationTest {
                    onlyIf {
                        !nonParallelTestFiles.isEmpty()
                    }
                    filter {
                        nonParallelTestFiles.each {f ->
                            logger.log(LogLevel.WARN, 'Testing {}', f.name - '.groovy')
                            includeTestsMatching("*${f.name - '.groovy'}")
                        }
                    }

                    maxParallelForks = 1
                    useJUnitPlatform {
                        // TODO Once spock handles jupiter tags then we can use this and remove the filter
                        //                        includeTags 'non-parallel'
                    }
                    binaryResultsDirectory.set(project.file("${project.testResultsDir}/nonParallelIntegrationTest/binary"))
                    reports {
                        junitXml.getOutputLocation().set project.file("${project.testResultsDir}/nonParallelIntegrationTest")
                    }
                    jacoco {
                        destinationFile = project.file("${project.buildDir}/jacoco/nonParallelIntegrationTest.exec")
                    }
                }
                project.mergeTestReports.reportOn(project.file("${project.testResultsDir}/nonParallelIntegrationTest/binary"))
            }
        }
        if (project.name != 'mdm-bom') {
            project.publishing {
                publications {
                    mavenJar {
                        pom {
                            name = project.name
                            url = 'https://github.com/MauroDataMapper/mdm-core'
                            licenses {
                                license {
                                    name = 'The Apache License, Version 2.0'
                                    url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                                }
                            }
                            developers {
                                developer {
                                    id = 'olliefreeman'
                                    name = 'Oliver Freeman'
                                    email = 'ollie.freeman@gmail.com'
                                }
                                developer {
                                    id = 'jameswelch'
                                    name = 'James Welch'
                                    email = 'james.welch@bdi.ox.ac.uk'
                                }
                            }
                            scm {
                                connection = 'git@github.com:MauroDataMapper/mdm-core.git'
                                developerConnection = 'git@github.com:MauroDataMapper/mdm-core.git'
                                url = 'https://github.com/MauroDataMapper/mdm-core'
                            }
                        }
                    }
                }
            }
        }
    }

}

afterEvaluate {
    /*
    Massive hack to solve parallel task running for assetCompile task
    Make sure that each task mustRunAfter another assetCompile task, this ensures none of them can run at the same time
    We have to allow for project dependencies so make sure thats accounted for manually
    */
    List<Task> assetCompileTasks = it.getTasksByName('assetCompile', true).toList().sort {it.path}

    Task coreTask = assetCompileTasks.find {it.path.startsWith(':mdm-core')}
    Task dataModelTask = assetCompileTasks.find {it.path.startsWith(':mdm-plugin-datamodel')}

    assetCompileTasks.remove(coreTask)
    assetCompileTasks.remove(dataModelTask)

    //    dataModelTask.mustRunAfter coreTask
    assetCompileTasks.each {
        it.mustRunAfter coreTask, dataModelTask
    }

    for (int i = 1; i < assetCompileTasks.size(); i++) {
        assetCompileTasks[i].mustRunAfter assetCompileTasks[i - 1]
    }

    logger.quiet 'Project: {} > group: {}, version {}', project.name, project.group, project.version
}

Set<Project> collectProjectDependencies(Project project) {
    Set<Project> dependencyProjects = new HashSet<>()
    ConfigurationContainer configurations = project.configurations
    Configuration configuration = configurations.findByName('implementation')
    if (configuration) {
        DomainObjectSet<ProjectDependency> projectDependencies = configuration.dependencies.withType ProjectDependency
        projectDependencies.forEach {
            dependencyProjects.add(it.dependencyProject)
            dependencyProjects.addAll(collectProjectDependencies(it.dependencyProject))
        }
    }
    dependencyProjects
}

FileCollection findNonParallelTestFiles(Project project) {
    project.fileTree('src/integration-test/groovy').filter {File f ->
        !f.name.find(/FunctionalSpec/) &&
        f.text.find(/@Tag\('non-parallel'\)/)
    }
}