build.gradle

/*
 * Copyright OpenSearch Contributors
 * SPDX-License-Identifier: Apache-2.0
 */

/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch licenses this file to you under
 * the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.opensearch.gradle.test.RestIntegTestTask
import org.opensearch.gradle.testclusters.StandaloneRestIntegTestTask
import org.opensearch.gradle.testclusters.OpenSearchCluster
import org.gradle.api.internal.tasks.testing.filter.DefaultTestFilter
import org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestFramework

import groovy.xml.XmlParser
import java.nio.file.Paths
import java.util.concurrent.Callable
import java.util.stream.Collectors

plugins {
    id "de.undercouch.download" version "5.3.0"
    id 'com.diffplug.spotless' version '6.22.0'
}

apply plugin: 'opensearch.build'
apply plugin: 'opensearch.rest-test'
apply plugin: 'java'
apply plugin: 'io.freefair.lombok'
apply plugin: 'com.wiredforcode.spawn'

String baseVersion = "2.17.0"
String bwcVersion = baseVersion + ".0";
String baseName = "sqlBwcCluster"
String bwcFilePath = "src/test/resources/bwc/"

repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }

    // Add extra repository for the JDBC driver if given by user
    if (System.getProperty("jdbcRepo") != null && new File(System.getProperty("jdbcRepo")).isDirectory()) {
        maven { url new File(System.getProperty("jdbcRepo")) }
    }
}

ext {
    projectSubstitutions = [:]
    licenseFile = rootProject.file('LICENSE.TXT')
    noticeFile = rootProject.file('NOTICE')

    getSecurityPluginDownloadLink = { ->
        var repo = "https://aws.oss.sonatype.org/content/repositories/snapshots/org/opensearch/plugin/" +
                   "opensearch-security/$opensearch_build_snapshot/"
        var metadataFile = Paths.get(projectDir.toString(), "build", "maven-metadata.xml").toAbsolutePath().toFile()
        download.run {
            src repo + "maven-metadata.xml"
            dest metadataFile
        }
        def metadata = new XmlParser().parse(metadataFile)
        def securitySnapshotVersion = metadata.versioning.snapshotVersions[0].snapshotVersion[0].value[0].text()

        return repo + "opensearch-security-${securitySnapshotVersion}.zip"
    }

    var projectAbsPath = projectDir.getAbsolutePath()
    File downloadedSecurityPlugin = Paths.get(projectAbsPath, 'bin', 'opensearch-security-snapshot.zip').toFile()
    configureSecurityPlugin = { OpenSearchCluster cluster ->

        cluster.getNodes().forEach { node ->
            var creds = node.getCredentials()
            if (creds.isEmpty()) {
                creds.add(Map.of('useradd', 'admin', '-p', 'admin'))
            } else {
                creds.get(0).putAll(Map.of('useradd', 'admin', '-p', 'admin'))
            }
        }

        // add a check to avoid re-downloading multiple times during single test run
        if (!downloadedSecurityPlugin.exists()) {
            download.run {
                src getSecurityPluginDownloadLink()
                dest downloadedSecurityPlugin
            }
        } else {
            println "Security Plugin File Already Exists"
        }

        // Config below including files are copied from security demo configuration
        ['esnode.pem', 'esnode-key.pem', 'root-ca.pem'].forEach { file ->
            File local = Paths.get(projectAbsPath, 'bin', file).toFile()
            download.run {
                src "https://raw.githubusercontent.com/opensearch-project/security/main/bwc-test/src/test/resources/security/" + file
                dest local
                overwrite false
            }
            cluster.extraConfigFile file, local
        }
        [
            // config copied from security plugin demo configuration
            'plugins.security.ssl.transport.pemcert_filepath' : 'esnode.pem',
            'plugins.security.ssl.transport.pemkey_filepath' : 'esnode-key.pem',
            'plugins.security.ssl.transport.pemtrustedcas_filepath' : 'root-ca.pem',
            'plugins.security.ssl.transport.enforce_hostname_verification' : 'false',
            // https is disabled to simplify test debugging
            'plugins.security.ssl.http.enabled' : 'false',
            'plugins.security.ssl.http.pemcert_filepath' : 'esnode.pem',
            'plugins.security.ssl.http.pemkey_filepath' : 'esnode-key.pem',
            'plugins.security.ssl.http.pemtrustedcas_filepath' : 'root-ca.pem',
            'plugins.security.allow_unsafe_democertificates' : 'true',

            'plugins.security.allow_default_init_securityindex' : 'true',
            'plugins.security.authcz.admin_dn' : 'CN=kirk,OU=client,O=client,L=test,C=de',
            'plugins.security.audit.type' : 'internal_opensearch',
            'plugins.security.enable_snapshot_restore_privilege' : 'true',
            'plugins.security.check_snapshot_restore_write_privileges' : 'true',
            'plugins.security.restapi.roles_enabled' : '["all_access", "security_rest_api_access"]',
            'plugins.security.system_indices.enabled' : 'true'
        ].forEach { name, value ->
            cluster.setting name, value
        }

        cluster.plugin provider((Callable<RegularFile>) (() -> (RegularFile) (() -> downloadedSecurityPlugin)))
    }

    bwcOpenSearchJSDownload = 'https://ci.opensearch.org/ci/dbc/distribution-build-opensearch/' + baseVersion + '/latest/linux/x64/tar/builds/' +
            'opensearch/plugins/opensearch-job-scheduler-' + bwcVersion + '.zip'
    bwcJobSchedulerPath = bwcFilePath + "job-scheduler/"
}

tasks.withType(licenseHeaders.class) {
    additionalLicense 'AL   ', 'Apache', 'Licensed under the Apache License, Version 2.0 (the "License")'
}

validateNebulaPom.enabled = false
loggerUsageCheck.enabled = false


configurations.all {
    resolutionStrategy.force 'junit:junit:4.13.2'
    resolutionStrategy.force "commons-logging:commons-logging:1.2"
    // enforce 1.1.3, https://www.whitesourcesoftware.com/vulnerability-database/WS-2019-0379
    resolutionStrategy.force 'commons-codec:commons-codec:1.13'
    resolutionStrategy.force "com.fasterxml.jackson.core:jackson-core:${versions.jackson}"
    resolutionStrategy.force "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${versions.jackson}"
    resolutionStrategy.force "com.fasterxml.jackson.dataformat:jackson-dataformat-smile:${versions.jackson}"
    resolutionStrategy.force "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:${versions.jackson}"
    resolutionStrategy.force "com.fasterxml.jackson.core:jackson-databind:${versions.jackson_databind}"
    resolutionStrategy.force "com.squareup.okhttp3:okhttp:4.12.0"
    resolutionStrategy.force "org.apache.httpcomponents:httpcore:4.4.13"
    resolutionStrategy.force "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.9.10"
    resolutionStrategy.force "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.10"
    resolutionStrategy.force "joda-time:joda-time:2.10.12"
    resolutionStrategy.force "org.slf4j:slf4j-api:1.7.36"
    resolutionStrategy.force "com.amazonaws:aws-java-sdk-core:${aws_java_sdk_version}"
    resolutionStrategy.force "com.google.guava:guava:${guava_version}"
}

configurations {
    zipArchive
}

dependencies {
    testImplementation group: 'org.opensearch.test', name: 'framework', version: "${opensearch_version}"
    testImplementation group: 'org.opensearch.client', name: 'opensearch-rest-high-level-client', version: "${opensearch_version}"
    testImplementation group: 'org.opensearch.client', name: 'opensearch-rest-client', version: "${opensearch_version}"
    testImplementation group: 'org.opensearch.driver', name: 'opensearch-sql-jdbc', version: System.getProperty("jdbcDriverVersion", '1.2.0.0')
    testImplementation group: 'org.hamcrest', name: 'hamcrest', version: '2.1'
    implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version:"${versions.log4j}"
    testImplementation project(':opensearch-sql-plugin')
    testImplementation project(':legacy')
    testImplementation('org.junit.jupiter:junit-jupiter-api:5.9.3')
    testRuntimeOnly('org.junit.jupiter:junit-jupiter-engine:5.9.3')
    testRuntimeOnly('org.junit.platform:junit-platform-launcher:1.9.3')

    testImplementation group: 'com.h2database', name: 'h2', version: '2.2.220'
    testImplementation group: 'org.xerial', name: 'sqlite-jdbc', version: '3.41.2.2'
    testImplementation group: 'com.google.code.gson', name: 'gson', version: '2.8.9'
    testCompileOnly 'org.apiguardian:apiguardian-api:1.1.2'

    // Needed for BWC tests
    zipArchive group: 'org.opensearch.plugin', name:'opensearch-job-scheduler', version: "${opensearch_build}"
    zipArchive group: 'org.opensearch.plugin', name:'opensearch-sql-plugin', version: "${bwcVersion}-SNAPSHOT"
}

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

dependencyLicenses.enabled = false
testingConventions.enabled = false
forbiddenApisTest.enabled = false
thirdPartyAudit.enabled = false

compileTestJava {
    options.compilerArgs.addAll(["-processor", 'lombok.launch.AnnotationProcessorHider$AnnotationProcessor'])
    doFirst { // Necessary because of many warnings in legacy SQL IT
        options.compilerArgs.remove('-Werror')
        options.compilerArgs.remove('-Xdoclint:all')
    }
}

testClusters.all {
    // debug with command, ./gradlew opensearch-sql:run -DdebugJVM. --debug-jvm does not work with keystore.
    if (System.getProperty("debugJVM") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'
    }
}

def getJobSchedulerPlugin() {
    provider(new Callable<RegularFile>() {
        @Override
        RegularFile call() throws Exception {
            return new RegularFile() {
                @Override
                File getAsFile() {
                    return configurations.zipArchive.asFileTree.matching {
                        include '**/opensearch-job-scheduler*'
                    }.singleFile
                }
            }
        }
    })
}

testClusters {
    integTest {
        testDistribution = 'archive'
        plugin(getJobSchedulerPlugin())
        plugin ":opensearch-sql-plugin"
        setting "plugins.query.datasources.encryption.masterkey", "1234567812345678"
    }
    remoteCluster {
        testDistribution = 'archive'
        plugin(getJobSchedulerPlugin())
        plugin ":opensearch-sql-plugin"
    }
    integTestWithSecurity {
        testDistribution = 'archive'
        plugin(getJobSchedulerPlugin())
        plugin ":opensearch-sql-plugin"
    }
    remoteIntegTestWithSecurity {
        testDistribution = 'archive'
        plugin(getJobSchedulerPlugin())
        plugin ":opensearch-sql-plugin"
    }
}

task startPrometheus(type: SpawnProcessTask) {
    mustRunAfter ':doctest:doctest'

    doFirst {
        download.run {
            src getPrometheusBinaryLocation()
            dest new File("$projectDir/bin", 'prometheus.tar.gz')
        }
        copy {
            from tarTree("$projectDir/bin/prometheus.tar.gz")
            into "$projectDir/bin"
        }
        file("$projectDir/bin").eachDir {
            if (it.name.startsWith("prometheus-")) {
                println "Renaming folder : " + it.name.toString()
                println it.renameTo("$projectDir/bin/prometheus")
            }
        }
    }
    command "$projectDir/bin/prometheus/prometheus --storage.tsdb.path=$projectDir/bin/prometheus/data --config.file=$projectDir/bin/prometheus/prometheus.yml"
    ready 'TSDB started'
}

task stopPrometheus(type: KillProcessTask) {
    doLast {
        file("$projectDir/bin/prometheus").deleteDir()
        file("$projectDir/bin/prometheus.tar.gz").delete()
    }
}

stopPrometheus.mustRunAfter startPrometheus

task integJdbcTest(type: RestIntegTestTask) {
    testClusters.findAll {c -> c.clusterName == "integJdbcTest"}.first().
        plugin ":opensearch-sql-plugin"

    useJUnitPlatform()
    dependsOn ':opensearch-sql-plugin:bundlePlugin'
    testLogging {
        events "passed", "skipped", "failed"
    }
    afterTest { desc, result ->
        logger.quiet "${desc.className}.${desc.name}: ${result.resultType} ${(result.getEndTime() - result.getStartTime())/1000}s"
    }

    if (System.getProperty("jdbcDriverVersion") != null) {
        systemProperty "jdbcDriverVersion", System.getProperty("jdbcDriverVersion")
    }

    if (System.getProperty("jdbcFile") != null) {
        systemProperty "jdbcFile", System.getProperty("jdbcFile")
    }

    systemProperty 'tests.security.manager', 'false'
    systemProperty('project.root', project.projectDir.absolutePath)

    systemProperty "https", System.getProperty("https")
    systemProperty "user", System.getProperty("user")
    systemProperty "password", System.getProperty("password")

    // Set default query size limit
    systemProperty 'defaultQuerySizeLimit', '10000'

    // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
    // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
    doFirst { systemProperty 'cluster.debug', getDebug() }

    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
    }

    filter {
        includeTestsMatching 'org.opensearch.sql.jdbc.*'
    }
}

task integTestWithSecurity(type: RestIntegTestTask) {
    useCluster testClusters.integTestWithSecurity
    useCluster testClusters.remoteIntegTestWithSecurity

    systemProperty "cluster.names",
        getClusters().stream().map(cluster -> cluster.getName()).collect(Collectors.joining(","))

    getClusters().forEach { cluster ->
        configureSecurityPlugin(cluster)
    }

    useJUnitPlatform()
    dependsOn ':opensearch-sql-plugin:bundlePlugin'
    testLogging {
        events "passed", "skipped", "failed"
    }
    afterTest { desc, result ->
        logger.quiet "${desc.className}.${desc.name}: ${result.resultType} ${(result.getEndTime() - result.getStartTime())/1000}s"
    }

    systemProperty 'tests.security.manager', 'false'
    systemProperty 'project.root', project.projectDir.absolutePath

    // Set default query size limit
    systemProperty 'defaultQuerySizeLimit', '10000'

    // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
    // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
    doFirst {
        systemProperty 'cluster.debug', getDebug()
        getClusters().forEach { cluster ->

            String allTransportSocketURI = cluster.nodes.stream().flatMap { node ->
                node.getAllTransportPortURI().stream()
            }.collect(Collectors.joining(","))
            String allHttpSocketURI = cluster.nodes.stream().flatMap { node ->
                node.getAllHttpSocketURI().stream()
            }.collect(Collectors.joining(","))

            systemProperty "tests.rest.${cluster.name}.http_hosts", "${-> allHttpSocketURI}"
            systemProperty "tests.rest.${cluster.name}.transport_hosts", "${-> allTransportSocketURI}"
        }

        systemProperty "https", "false"
        systemProperty "user", "admin"
        systemProperty "password", "admin"
    }

    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
    }

    // NOTE: this IT config discovers only junit5 (jupiter) tests.
    // https://github.com/opensearch-project/sql/issues/1974
    filter {
        includeTestsMatching 'org.opensearch.sql.security.CrossClusterSearchIT'
    }
}

// Run PPL ITs and new, legacy and comparison SQL ITs with new SQL engine enabled
integTest {
    useCluster testClusters.remoteCluster

    // Set properties for connection to clusters and between clusters
    doFirst {
        getClusters().forEach { cluster ->
            String allTransportSocketURI = cluster.nodes.stream().flatMap { node ->
                node.getAllTransportPortURI().stream()
            }.collect(Collectors.joining(","))
            String allHttpSocketURI = cluster.nodes.stream().flatMap { node ->
                node.getAllHttpSocketURI().stream()
            }.collect(Collectors.joining(","))

            systemProperty "tests.rest.${cluster.name}.http_hosts", "${-> allHttpSocketURI}"
            systemProperty "tests.rest.${cluster.name}.transport_hosts", "${-> allTransportSocketURI}"
        }
    }

    testLogging {
        events "passed", "skipped", "failed"
    }

    dependsOn ':opensearch-sql-plugin:bundlePlugin'
    if(getOSFamilyType() != "windows") {
        dependsOn startPrometheus
        finalizedBy stopPrometheus
    }
    systemProperty 'tests.security.manager', 'false'
    systemProperty('project.root', project.projectDir.absolutePath)

    systemProperty "https", System.getProperty("https")
    systemProperty "user", System.getProperty("user")
    systemProperty "password", System.getProperty("password")

    // Set default query size limit
    systemProperty 'defaultQuerySizeLimit', '10000'

    // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
    // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
    doFirst {
        if (System.getProperty("debug-jvm") != null) {
            setDebug(true);
        }
        systemProperty 'cluster.debug', getDebug()
    }


    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5006'
    }

    if (System.getProperty("tests.rest.bwcsuite") == null) {
        filter {
            excludeTestsMatching "org.opensearch.sql.bwc.*IT"
        }
    }

    if(getOSFamilyType() == "windows") {
        exclude 'org/opensearch/sql/ppl/PrometheusDataSourceCommandsIT.class'
        exclude 'org/opensearch/sql/ppl/ShowDataSourcesCommandIT.class'
        exclude 'org/opensearch/sql/ppl/InformationSchemaCommandIT.class'
    }

    exclude 'org/opensearch/sql/doctest/**/*IT.class'
    exclude 'org/opensearch/sql/correctness/**'

    // Explain IT is dependent on internal implementation of old engine so it's not necessary
    // to run these with new engine and not necessary to make this consistent with old engine.
    exclude 'org/opensearch/sql/legacy/ExplainIT.class'
    exclude 'org/opensearch/sql/legacy/PrettyFormatterIT.class'
    exclude 'org/opensearch/sql/legacy/TermQueryExplainIT.class'

    // Skip old semantic analyzer IT because analyzer in new engine has different behavior
    exclude 'org/opensearch/sql/legacy/QueryAnalysisIT.class'

    // Skip this IT because all assertions are against explain output
    exclude 'org/opensearch/sql/legacy/OrderIT.class'

    // Exclude JDBC related tests
    exclude 'org/opensearch/sql/jdbc/**'

    // Exclude this IT, because they executed in another task (:integTestWithSecurity)
    exclude 'org/opensearch/sql/security/**'
}


task comparisonTest(type: RestIntegTestTask) {
    testLogging {
        events "passed", "skipped", "failed"
    }
    dependsOn ':opensearch-sql-plugin:bundlePlugin'

    systemProperty 'tests.security.manager', 'false'
    systemProperty('project.root', project.projectDir.absolutePath)

    // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
    // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
    doFirst { systemProperty 'cluster.debug', getDebug() }

    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
    }

    include 'org/opensearch/sql/correctness/**/*IT.class'
    exclude 'org/opensearch/sql/doctest/**/*IT.class'
    exclude 'org/opensearch/sql/ppl/**/*IT.class'
    exclude 'org/opensearch/sql/legacy/**/*IT.class'

    // Exclude JDBC related tests
    exclude 'org/opensearch/sql/jdbc/**'

    // Enable logging output to console
    testLogging.showStandardStreams true

    // Pass down system properties to IT class
    systemProperty "esHost", System.getProperty("esHost")
    systemProperty "dbUrl", System.getProperty("dbUrl")
    systemProperty "otherDbUrls", System.getProperty("otherDbUrls")
    systemProperty "queries", System.getProperty("queries")
}

2.times { i ->
    testClusters {
        "${baseName}$i" {
            testDistribution = "ARCHIVE"
            versions = [baseVersion, opensearch_version]
            numberOfNodes = 3
            plugin(provider(new Callable<RegularFile>(){
                @Override
                RegularFile call() throws Exception {
                    return new RegularFile() {
                        @Override
                        File getAsFile() {
                            if (new File("$project.rootDir/$bwcFilePath/job-scheduler/$bwcVersion").exists()) {
                                project.delete(files("$project.rootDir/$bwcFilePath/job-scheduler/$bwcVersion"))
                            }
                            project.mkdir bwcJobSchedulerPath + bwcVersion
                            ant.get(src: bwcOpenSearchJSDownload,
                                    dest: bwcJobSchedulerPath + bwcVersion,
                                    httpusecaches: false)
                            return fileTree(bwcJobSchedulerPath + bwcVersion).getSingleFile()
                        }
                    }
                }
            }))
            plugin(provider(new Callable<RegularFile>(){
                @Override
                RegularFile call() throws Exception {
                    return new RegularFile() {
                        @Override
                        File getAsFile() {
                            return configurations.zipArchive.asFileTree.matching {
                                include '**/opensearch-sql-plugin*'
                            }.singleFile
                        }
                    }
                }
            }))
            setting 'path.repo', "${buildDir}/cluster/shared/repo/${baseName}"
            setting 'http.content_type.required', 'true'
        }
    }
}

List<Provider<RegularFile>> plugins = [
        getJobSchedulerPlugin(),
        provider(new Callable<RegularFile>() {
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return fileTree(bwcFilePath + project.version).getSingleFile()
                    }
                }
            }
        })
]

// Creates 2 test clusters with 3 nodes of the old version.
2.times { i ->
    task "${baseName}#oldVersionClusterTask$i"(type: StandaloneRestIntegTestTask) {
        useCluster testClusters."${baseName}$i"
        filter {
            includeTestsMatching "org.opensearch.sql.bwc.*IT"
        }
        systemProperty 'tests.rest.bwcsuite', 'old_cluster'
        systemProperty 'tests.rest.bwcsuite_round', 'old'
        systemProperty 'tests.plugin_bwc_version', bwcVersion
        nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}$i".allHttpSocketURI.join(",")}")
        nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}$i".getName()}")
    }
}

// Upgrade one node of the old cluster to new OpenSearch version with upgraded plugin version.
// This results in a mixed cluster with 2 nodes on the old version and 1 upgraded node.
// This is also used as a one third upgraded cluster for a rolling upgrade.
task "${baseName}#mixedClusterTask"(type: StandaloneRestIntegTestTask) {
    useCluster testClusters."${baseName}0"
    dependsOn "${baseName}#oldVersionClusterTask0"
    doFirst {
        testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
        includeTestsMatching "org.opensearch.sql.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'first'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrade the second node to new OpenSearch version with upgraded plugin version after the first node is upgraded.
// This results in a mixed cluster with 1 node on the old version and 2 upgraded nodes.
// This is used for rolling upgrade.
task "${baseName}#twoThirdsUpgradedClusterTask"(type: StandaloneRestIntegTestTask) {
    dependsOn "${baseName}#mixedClusterTask"
    useCluster testClusters."${baseName}0"
    doFirst {
        testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
        includeTestsMatching "org.opensearch.sql.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'second'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrade the third node to new OpenSearch version with upgraded plugin version after the second node is upgraded.
// This results in a fully upgraded cluster.
// This is used for rolling upgrade.
task "${baseName}#rollingUpgradeClusterTask"(type: StandaloneRestIntegTestTask) {
    dependsOn "${baseName}#twoThirdsUpgradedClusterTask"
    useCluster testClusters."${baseName}0"
    doFirst {
        testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
        includeTestsMatching "org.opensearch.sql.bwc.*IT"
    }
    mustRunAfter "${baseName}#mixedClusterTask"
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'third'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrade all the nodes of the old cluster to new OpenSearch version with upgraded plugin version
// at the same time resulting in a fully upgraded cluster.
task "${baseName}#fullRestartClusterTask"(type: StandaloneRestIntegTestTask) {
    dependsOn "${baseName}#oldVersionClusterTask1"
    useCluster testClusters."${baseName}1"
    doFirst {
        testClusters."${baseName}1".upgradeAllNodesAndPluginsToNextVersion(plugins)
    }
    filter {
        includeTestsMatching "org.opensearch.sql.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'upgraded_cluster'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}1".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}1".getName()}")
}

// A bwc test suite which runs all the bwc tasks combined
task bwcTestSuite(type: StandaloneRestIntegTestTask) {
    testLogging {
        events "passed", "skipped", "failed"
    }
    exclude '**/*Test*'
    exclude '**/*IT*'
    dependsOn tasks.named("${baseName}#mixedClusterTask")
    dependsOn tasks.named("${baseName}#rollingUpgradeClusterTask")
    dependsOn tasks.named("${baseName}#fullRestartClusterTask")
}

def opensearch_tmp_dir = rootProject.file('build/private/es_tmp').absoluteFile
opensearch_tmp_dir.mkdirs()

spotless {
    java {
        target fileTree('.') {
            include '**/*.java'
            exclude '**/build/**', '**/build-*/**'
        }
        importOrder()
//        licenseHeader("/*\n" +
//                " * Copyright OpenSearch Contributors\n" +
//                " * SPDX-License-Identifier: Apache-2.0\n" +
//                " */\n\n")
        removeUnusedImports()
        trimTrailingWhitespace()
        endWithNewline()
        googleJavaFormat('1.17.0').reflowLongStrings().groupArtifact('com.google.googlejavaformat:google-java-format')
    }
}

task integTestRemote(type: RestIntegTestTask) {
    testLogging {
        events "passed", "skipped", "failed"
    }
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    systemProperty 'tests.security.manager', 'false'
    systemProperty('project.root', project.projectDir.absolutePath)
    systemProperty 'java.io.tmpdir', opensearch_tmp_dir.absolutePath

    systemProperty "https", System.getProperty("https")
    systemProperty "user", System.getProperty("user")
    systemProperty "password", System.getProperty("password")

    // Set default query size limit
    systemProperty 'defaultQuerySizeLimit', '10000'

    if (System.getProperty("tests.rest.bwcsuite") == null) {
        filter {
            excludeTestsMatching "org.opensearch.sql.bwc.*IT"
        }
    }

    // Exclude the same tests that are excluded for integTest
    exclude 'org/opensearch/sql/doctest/**/*IT.class'
    exclude 'org/opensearch/sql/correctness/**'
    exclude 'org/opensearch/sql/legacy/ExplainIT.class'
    exclude 'org/opensearch/sql/legacy/PrettyFormatterIT.class'
    exclude 'org/opensearch/sql/legacy/TermQueryExplainIT.class'
    exclude 'org/opensearch/sql/legacy/QueryAnalysisIT.class'
    exclude 'org/opensearch/sql/legacy/OrderIT.class'
    exclude 'org/opensearch/sql/jdbc/**'
}