build.gradle

import org.apache.tools.ant.filters.ReplaceTokens

import java.nio.file.Path
import java.nio.file.Paths

buildscript {
    apply(from: "dependencies.gradle")

    repositories {
        mavenCentral()
        gradlePluginPortal()
        maven {
            url = uri("https://plugins.gradle.org/m2/")
        }
    }

    dependencies {
        classpath(libraries.springDependencyManagementGradlePlugin)
        classpath(libraries.springBootGradlePlugin)
        classpath(libraries.gradleJcocoPlugin)
        classpath(libraries.sonarqubePlugin)
    }
}

apply(from: "dependencies.gradle")

allprojects {
    apply(plugin: "io.spring.dependency-management")
    apply(plugin: "org.barfuin.gradle.jacocolog")
    apply(plugin: "org.sonarqube")

    dependencyManagement {
        imports {
            mavenBom(libraries.springBootBom)
        }
    }

    repositories {
        mavenCentral()
        maven {
            url = uri("https://build.shibboleth.net/nexus/content/repositories/releases/")
        }
        maven { url = uri("https://repository.mulesoft.org/releases/") }
    }
}


subprojects {
    /** Log each test PASSED/SKIPPED/FAILED unless disabled (-PverboseTests=false or UAA_VERBOSE_TESTS=0/off). */
    def uaaVerboseTestRaw = (findProperty('verboseTests') ?: System.getenv('UAA_VERBOSE_TESTS') ?: 'true')
            .toString().trim().toLowerCase()
    def uaaVerboseTestEvents = !['false', '0', 'off', 'no'].contains(uaaVerboseTestRaw)

    apply(plugin: "java")
    java {
        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }

    configurations.configureEach {
        exclude(group: "org.hamcrest", module: "hamcrest-all")
        exclude(group: "org.hamcrest", module: "hamcrest-core")
        exclude(group: "org.hamcrest", module: "hamcrest-library")
        exclude(group: "org.springframework.boot", module: "spring-boot-starter-logging")
        exclude(group: "org.skyscreamer", module: "jsonassert")
        exclude(group: "com.vaadin.external.google", module: "android-json")
        exclude(group: "com.unboundid.components", module: "json")

        // Exclude opensaml-security-api and non-FIPS bouncycastle libs, and use Shadow library for FIPS compliance
        exclude(group: "org.bouncycastle", module: "bcpkix-jdk15on")
        exclude(group: "org.bouncycastle", module: "bcprov-jdk15on")
        exclude(group: "org.bouncycastle", module: "bcutil-jdk15on")
        exclude(group: "org.bouncycastle", module: "bcprov-jdk18on")
        exclude(group: "org.bouncycastle", module: "bcpkix-jdk18on")
        exclude(group: "org.bouncycastle", module: "bcutil-jdk18on")

        resolutionStrategy {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                if (details.requested.group == 'org.opensaml' && details.requested.name.startsWith("opensaml-")) {
                    details.useVersion "${versions.opensaml}"
                    details.because 'Spring Security 5.8.x allows OpenSAML 3 or 4. OpenSAML 3 has reached its end-of-life. Spring Security 6 drops support for 3, using 4.'
                }
            }
        }
    }

    dependencies {
        testImplementation(libraries.springBootStarterTest) {
            exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
        }
        testImplementation(libraries.hamcrest)
        testImplementation(libraries.junit5JupiterApi)
        testImplementation(libraries.junit5JupiterParams)
        testImplementation(libraries.junit5JupiterEngine)
        testImplementation(libraries.unboundIdLdapSdk)
        testRuntimeOnly(libraries.jacocoAgent)

        // Ensure test runtime dependencies are included
        testRuntimeOnly('org.junit.platform:junit-platform-launcher')

        compileOnly(libraries.lombok)
        annotationProcessor(libraries.lombok)
    }

    [compileJava, compileTestJava]*.options*.compilerArgs = ["-Xlint:none", "-nowarn", "-parameters"]

    test {
        // when failFast = true AND retry is on, there is a serious issue:
        // gradle might stop the test run due to the failFast but still concludes with BUILD SUCCESSFUL (if the retry is successful)
        failFast = false
        useJUnitPlatform()
        // Reduced from 1024m to 640m - unit tests don't need as much as integration tests
        jvmArgs += ["-Xmx640m",
                    "-XX:+StartAttachListener",
                    "-XX:+HeapDumpOnOutOfMemoryError",
                    "-XX:HeapDumpPath=/var/log/uaa-tests.hprof"
        ]

        // Enable test timing to identify slow tests
        // This helps debug CI performance issues
        reports {
            junitXml.required = true
            html.required = true
        }

        testLogging {
            if (uaaVerboseTestEvents) {
                events("passed", "skipped", "failed")
            } else {
                events("failed")
            }
            exceptionFormat = "full"
            // Set showStandardStreams=true to see all standard output from tests (there's a ton of it!)
            showStandardStreams = false
            showCauses = true
            showExceptions = true
            showStackTraces = true
        }

        // Add system property to enable detailed test timing
        systemProperty("junit.jupiter.execution.timeout.default", System.getProperty("junit.jupiter.execution.timeout.default", "0"))

        // Log slow tests to help identify bottlenecks
        afterTest { descriptor, result ->
            def duration = result.endTime - result.startTime
            if (duration > 10000) { // 10 seconds
                logger.warn("SLOW TEST: ${descriptor.className}.${descriptor.name} took ${duration}ms")
            }
        }

        // Log summary of test execution times
        afterSuite { descriptor, result ->
            if (descriptor.parent == null) {
                def duration = result.endTime - result.startTime
                def testLabel = result.testCount == 1 ? "unit-test" : "unit-tests"
                logger.lifecycle("[${project.name}] Completed ${result.testCount} ${testLabel} in ${duration}ms (passed=${result.successfulTestCount};failed=${result.failedTestCount};skipped=${result.skippedTestCount})")
            }
        }
    }

    tasks.register('integrationTest', Test) {
        dependsOn subprojects.integrationTest
        
        useJUnitPlatform()

        // This prevents integrationTests from hanging indefinitely
        timeout = Duration.ofMinutes(180)
        
        // Integration test workers need same memory as unit tests
        // Actual CI configuration is controlled via integration_tests.sh script
        jvmArgs += ["-Xmx640m",
                    "-XX:+StartAttachListener",
                    "-XX:+HeapDumpOnOutOfMemoryError",
                    "-XX:HeapDumpPath=/var/log/uaa-tests.hprof"
        ]

        // Enable JaCoCo for integration tests
        jacoco {
            enabled = true
        }

        testLogging {
            if (uaaVerboseTestEvents) {
                events("passed", "skipped", "failed")
            } else {
                events("failed")
            }
            exceptionFormat = "full"
            // Set showStandardStreams=true to see all standard output from tests (there's a ton of it!)
            showStandardStreams = false
            showCauses = true
            showExceptions = true
            showStackTraces = true
        }

        // Add system property to enable detailed test timing
        systemProperty("junit.jupiter.execution.timeout.default", System.getProperty("junit.jupiter.execution.timeout.default", "0"))

        // Log slow tests to help identify bottlenecks
        afterTest { descriptor, result ->
            def duration = result.endTime - result.startTime
            if (duration > 20000) { // 20 seconds
                logger.warn("SLOW TEST: ${descriptor.className}.${descriptor.name} took ${duration}ms")
            }
        }

        // Log summary of test execution times
        afterSuite { descriptor, result ->
            if (descriptor.parent == null) {
                def duration = result.endTime - result.startTime
                def testLabel = result.testCount == 1 ? "integration-test" : "integration-tests"
                logger.lifecycle("[${project.name}] Completed ${result.testCount} ${testLabel} in ${duration}ms (passed=${result.successfulTestCount};failed=${result.failedTestCount};skipped=${result.skippedTestCount})")
            }
        }
    }

    tasks.register('generateDocs') {}

    tasks.register('allDeps', DependencyReportTask) {}

    tasks.register('writeNewPom') {
        doLast {
            pom {
                project {
                    licenses {
                        license {
                            name("The Apache Software License, Version 2.0")
                            url("http://www.apache.org/licenses/LICENSE-2.0.txt")
                            distribution("repo")
                        }
                    }
                }
            }.writeTo("./pom.xml")
        }
    }

    repositories {
        mavenCentral()
        maven {
            url = uri("https://jitpack.io")
        }
        maven {
            url = uri("https://repo.maven.apache.org/maven2")
        }
    }
}

sonarqube {
    properties {
        property "sonar.projectKey", "cloudfoundry-identity-parent"
        property "sonar.organization", "cloudfoundry-1"
        property "sonar.host.url", "https://sonarcloud.io"
        property "sonar.exclusions", "samples/**/*.*,**/*Test.java,**/*Tests.java,**/*IT.java,**/*SecurityConfiguration.java"
        property "sonar.java.source", JavaVersion.current()
    }
}

project.gradle.taskGraph.whenReady { TaskExecutionGraph graph ->
    project.allprojects.collect({ it.tasks.withType(Test) }).flatten().each {
        it.systemProperty("spring.profiles.active", System.getProperty("spring.profiles.active", "hsqldb"))
        it.systemProperty("testId", System.getProperty("testId", ""))
        it.systemProperty("zones.paths.enabled", System.getProperty("zones.paths.enabled", "true"))
    }
}

tasks.register('manifests', Copy) {
    dependsOn subprojects.assemble
    from("uaa/src/test/resources/sample-manifests") {
        include("**/*.yml")
        filter(ReplaceTokens,
                tokens: [
                        version  : version,
                        app      : System.getProperty("app", "myuaa"),
                        appdomain: System.getProperty("app-domain", "bosh-lite.com"),
                ]
        )
    }
    into("build/sample-manifests")
}

tasks.register('cleanBootTomcatDir') {
    doLast {
        String tomcatBase = file("scripts/boot/tomcat/").getAbsolutePath()
        delete(Path.of(tomcatBase))
        Paths.get(tomcatBase, "work").toFile().mkdirs()
        Paths.get(tomcatBase, "webapps").toFile().mkdirs()
    }
}

tasks.register('bootWarRun', JavaExec) {
    dependsOn cleanBootTomcatDir
    dependsOn subprojects.assemble
    classpath = files(file("uaa/build/libs/cloudfoundry-identity-uaa-0.0.0.war"))
    systemProperty("server.tomcat.basedir", file("scripts/boot/tomcat/").getAbsolutePath())
    systemProperty("SECRETS_DIR", System.getProperty("SECRETS_DIR", file("scripts/boot").getAbsolutePath()))
    systemProperty("spring.profiles.active", System.getProperty("spring.profiles.active", "hsqldb"))
    systemProperty("metrics.perRequestMetrics", System.getProperty("metrics.perRequestMetrics", "true"))
    systemProperty("smtp.host", "localhost")
    systemProperty("smtp.port", 2525)
    systemProperty("java.security.egd", "file:/dev/./urandom")
    systemProperty("CLOUDFOUNDRY_CONFIG_PATH", file("scripts/boot").getAbsolutePath())
    systemProperty("server.servlet.context-path", "/uaa")
    systemProperty("statsd.enabled", "true")
    systemProperty("logging.config", file("scripts/boot/log4j2.properties").getAbsolutePath())
    systemProperty("zones.paths.enabled", System.getProperty("zones.paths.enabled", "true"))
}

tasks.register('killUaa', Exec) {
    workingDir './'
    executable = 'scripts/kill_uaa.sh'
}

/**
 * Writes the resolved tomcat-embed-core version (from the Spring Boot BOM) to
 * {@code build/tomcat-distribution.version} for scripts that download a matching
 * Apache Tomcat binary distribution (standalone integration tests).
 */
tasks.register('writeTomcatDistributionVersion') {
    group = 'build'
    description = 'Writes build/tomcat-distribution.version from tomcat-embed-core on cloudfoundry-identity-uaa runtimeClasspath'
    def uaaProject = project(':cloudfoundry-identity-uaa')
    def outFile = layout.buildDirectory.file('tomcat-distribution.version')
    outputs.file(outFile)
    doLast {
        def cfg = uaaProject.configurations.named('runtimeClasspath').get()
        def artifact = cfg.resolvedConfiguration.resolvedArtifacts.find { it.name == 'tomcat-embed-core' }
        if (artifact == null) {
            throw new GradleException('Could not resolve tomcat-embed-core version from :cloudfoundry-identity-uaa runtimeClasspath')
        }
        outFile.get().asFile.parentFile.mkdirs()
        outFile.get().asFile.text = artifact.moduleVersion.id.version
    }
}

tasks.register('printTomcatDistributionVersion') {
    group = 'help'
    description = 'Prints the Apache Tomcat version matching Spring Boot embedded tomcat-embed-core'
    dependsOn('writeTomcatDistributionVersion')
    doLast {
        println file("${layout.buildDirectory.get().asFile}/tomcat-distribution.version").text.trim()
    }
}

tasks.register('run') {
    dependsOn killUaa
    dependsOn ':cloudfoundry-identity-uaa:bootRun'
    description = "Kills any running UAA and starts the application. Use -Pdebug to enable debug mode (starts immediately) or -Pdebugs to enable debug mode with suspend (waits for debugger). Default port 5005, configurable with -PdebugPort=<port>"
    group = "application"
}