build.gradle

plugins {
    id 'java-library'
    id "com.diffplug.gradle.spotless" version "3.24.3"
    id 'io.codearte.nexus-staging' version '0.21.2'
    id "de.marcphilipp.nexus-publish" version "0.3.0"
    id "com.github.johnrengelman.shadow" version "5.2.0"
    id "org.cyclonedx.bom" version "1.8.2"
}

version =  getGitVersion()

ext {
    releaseVersion = getReleaseVersion()
    javaDataLoader = "com.mongodb.jdbc.integration.testharness.DataLoader"
    javaTestGenerator = "com.mongodb.jdbc.integration.testharness.TestGenerator"
    aspectjVersion = '1.9.7'
}

spotless {
    java {
        googleJavaFormat('1.1').aosp()
        licenseHeaderFile('resources/license_header.txt')
    }
}

cyclonedxBom {
    // includeConfigs is the list of configuration names to include when generating the BOM (leave empty to include every configuration), regex is supported
    includeConfigs = ["runtimeClasspath"]
    // skipConfigs is a list of configuration names to exclude when generating the BOM, regex is supported
    skipConfigs = ["testCompileClasspath", "testRuntimeClass", "testRuntimeOnly"]
    // skipProjects is a list of project names to exclude when generating the BOM
    skipProjects = ["integration-test", "demo", "smoketest"]
    // Specified the type of project being built. Defaults to 'library'
    projectType = "library"
    // Specified the version of the CycloneDX specification to use. Defaults to '1.5'
    schemaVersion = "1.5"
    // Boms destination directory. Defaults to 'build/reports'
    destination = file(cyclonedxBomDestination)
    // The file name for the generated BOMs (before the file format suffix). Defaults to 'bom'
    outputName = cyclonedxBomName
    // The file format generated, can be xml, json or all for generating both. Defaults to 'all'
    outputFormat = "json"
    // Exclude BOM Serial Number. Defaults to 'true'
    includeBomSerialNumber = false
    // Exclude License Text. Defaults to 'true'
    includeLicenseText = false
}

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

allprojects {
    apply plugin: 'idea'
    apply plugin: 'java'
    apply plugin: 'com.github.johnrengelman.shadow'

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = sourceCompatibility

    repositories {
        mavenCentral()
    }

    configurations {
        ajc
        aspects
        compile {
            extendsFrom aspects
        }
        sbom
    }

    dependencies {
        // MongoDB
        ajc "org.aspectj:aspectjtools:$aspectjVersion"
        implementation "org.aspectj:aspectjrt:$aspectjVersion"
        implementation group: 'org.mongodb', name: 'mongodb-driver-sync', version: mongodbDriverVersion
        implementation group: 'com.google.guava', name: 'guava', version: guavaVersion
        implementation group: 'org.apache.commons', name: 'commons-lang3', version: lang3Version
        ajc "org.aspectj:aspectjtools:$aspectjVersion"

        // Test
        testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitJupiterVersion
        testRuntimeOnly  group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: junitJupiterVersion
        testCompile  group: 'org.mockito', name: 'mockito-core', version: mockitoVersion
        testCompile  group: 'org.mockito', name: 'mockito-junit-jupiter', version: mockitoVersion
    }

    //ant.lifecycleLogLevel = AntBuilder.AntMessagePriority.VERBOSE

    compileJava {
        doLast {
            ant.taskdef(resource: "org/aspectj/tools/ant/taskdefs/aspectjTaskdefs.properties",
                    classpath: configurations.ajc.asPath)

            ant.iajc(
                    maxmem: "1024m", fork: "true", Xlint: "ignore",
                    destDir: project.sourceSets.main.output.classesDirs[0].absolutePath,
                    sourceroots: project.sourceSets.main.java.srcDirs[0].absolutePath,
                    classpath: project.sourceSets.main.runtimeClasspath.asPath,
                    source: project.sourceCompatibility,
                    target: project.targetCompatibility,
                    showWeaveInfo: true
            )
        }
    }

    test {
        useJUnitPlatform()
        failFast = true
    }

    task sourceJar(type: Jar) {
        from sourceSets.main.allJava
        classifier "sources"
    }

    task testJar(type: Jar) {
        from sourceSets.test.allJava
        classifier "test"
    }

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

    artifacts {
        sourceJar
        testJar
        javadocJar
    }
}

configurations {
    integrationTestImplementation.extendsFrom implementation
    integrationTestRuntimeOnly.extendsFrom runtimeOnly

    // Use the release version instead of gitVersion for the produced jar
    jar.archiveVersion = releaseVersion
    shadowJar.archiveVersion = releaseVersion
}

task integrationTest(type: Test) {
    useJUnitPlatform()
    description = 'Runs integration tests.'
    group = 'verification'

    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    shouldRunAfter test
}

check.dependsOn integrationTest

task runTestGenerator(type: JavaExec) {
    group = "Execution"
    description = "Run the integration test baseline file generator."
    classpath = sourceSets.integrationTest.runtimeClasspath
    main = javaTestGenerator
}

task runDataLoader(type: JavaExec) {
    group = "Execution"
    description = "Run the data loader."
    classpath = sourceSets.integrationTest.runtimeClasspath
    main = javaDataLoader
}

task runServer(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestRFC8252Server'
}

task runAuthFlow(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestOidcAuthFlow'
}

task runAuthFlowAndRefresh(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestOidcAuthFlowAndRefresh'
}

task runCallback(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestOidcCallback'
}

task runCallbackWithShortTimeout(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestOidcCallbackWithShortTimeout'
}

task runCallbackWithBadRefreshToken(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'com.mongodb.jdbc.oidc.manualtests.TestOidcCallbackWithBadRefreshToken'
}

jar {
    manifest {
        attributes('Implementation-Title': project.name,
                'Implementation-Version': project.version)
    }
}

dependencies {
    integrationTestImplementation "org.yaml:snakeyaml:$snakeYamlVersion"
    api "org.mongodb:mongodb-driver-sync:$mongodbDriverVersion"
    integrationTestImplementation "org.junit.jupiter:junit-jupiter:$junitJupiterVersion"
    integrationTestImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitJupiterVersion
    implementation group: 'org.thymeleaf', name: 'thymeleaf', version: thymeLeafVersion
    implementation group: 'com.nimbusds', name: 'oauth2-oidc-sdk', version: oauth2OIDCVersion
}

def getReleaseVersion() {
	def snapshot = isDirtyVersion() || !isTaggedVersion()
	if (snapshot) {
		return getAbbreviatedGitVersion() + "-SNAPSHOT"
	} else {
		return getGitVersion()
	}
}

def isDirtyVersion() {
	getGitVersion().endsWith("dirty")
}

def isTaggedVersion() {
	def out = new ByteArrayOutputStream()
	def result = exec {
		commandLine 'git', 'describe', '--exact'
		ignoreExitValue true
		standardOutput out
		errorOutput out
	}
	if (result.getExitValue() == 0) {
		return true
	} else {
		return false
	}
}

def getGitVersion() {
    def out = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--tags', '--always', '--dirty'
        standardOutput = out
    }
    out.toString().substring(1).trim()
}

def getAbbreviatedGitVersion() {
    def out = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--abbrev=0'
        standardOutput = out
    }
    out.toString().substring(1).trim()
}

tasks.register('runMongoSQLTranslateLibTest', Test) {
    description = 'Runs MongoSQLTranslateLibTest'
    group = 'verification'

    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath

    useJUnitPlatform()

    filter {
        if (project.hasProperty('testMethod')) {
            includeTestsMatching "*MongoSQLTranslateLibTest.$testMethod"
        } else {
            includeTestsMatching "*MongoSQLTranslateLibTest"
        }
    }
}

tasks.test {
    filter {
        excludeTestsMatching "*MongoSQLTranslateLibTest"
    }
}

apply from: 'gradle/publish.gradle'
apply from: 'gradle/deploy.gradle'