build.gradle

import java.util.regex.Matcher

plugins {
    id 'net.researchgate.release' version '2.8.1'
    id 'com.github.johnrengelman.shadow' version '7.1.2'
}

ext {
    ossrhUsername = project.findProperty('ossrh.username')
    ossrhPassword = project.findProperty('ossrh.password')

    testSuites = [
            [name: 'default', versions: [
                    [name: 'suite', 'zonky-postgres': 'default', opentable: 'default', yandex: 'default', 'mssql-driver': 'default', 'mysql-driver': 'default', 'mariadb-driver': 'default', 'h2': 'default', 'hsqldb': 'default', 'derby': 'default']
            ]],
            [name: 'spring', versions: [
                    [name: '4.3.8',   spring: '4.3.8.RELEASE',   'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default'],
                    [name: '4.3.30',  spring: '4.3.30.RELEASE',  'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default'],
                    [name: '5.0.20',  spring: '5.0.20.RELEASE',  'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default'],
                    [name: '5.1.20',  spring: '5.1.20.RELEASE',  'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default'],
                    [name: '5.2.22',  spring: '5.2.22.RELEASE',  'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default'],
                    [name: '5.3.23',  spring: '5.3.23',          'zonky-postgres': 'default',  opentable: 'default',  yandex: 'default',  'mssql-driver': 'default',  'mysql-driver': 'default',  'mariadb-driver': 'default',  'h2': 'default',  'hsqldb': 'default',  'derby': 'default']
            ]],
            [name: 'flyway', versions: [
                    [name: '4.0.3',  flyway: '4.0.3',   'flyway-test': '4.0.1',    spring: '4.3.30.RELEASE',  'spring-boot': '1.5.22.RELEASE',  'zonky-postgres': 'default'],
                    [name: '4.1.2',  flyway: '4.1.2',   'flyway-test': '4.1.0',    spring: '4.3.30.RELEASE',  'spring-boot': '1.5.22.RELEASE',  'zonky-postgres': 'default'],
                    [name: '4.2.0',  flyway: '4.2.0',   'flyway-test': '4.2.0.2',  spring: '4.3.30.RELEASE',  'spring-boot': '1.5.22.RELEASE',  'zonky-postgres': 'default'],
                    [name: '5.0.7',  flyway: '5.0.7',   'flyway-test': '5.0.0',    spring: '5.0.20.RELEASE',  'spring-boot': '2.0.9.RELEASE',   'zonky-postgres': 'default'],
                    [name: '5.1.4',  flyway: '5.1.4',   'flyway-test': '5.1.0',    spring: '5.0.20.RELEASE',  'spring-boot': '2.0.9.RELEASE',   'zonky-postgres': 'default'],
                    [name: '5.2.4',  flyway: '5.2.4',   'flyway-test': '5.2.4',    spring: '5.1.20.RELEASE',  'spring-boot': '2.1.18.RELEASE',  'zonky-postgres': 'default'],
                    [name: '6.0.3',  flyway: '6.0.3',   'flyway-test': '6.0.0',    spring: '5.2.12.RELEASE',  'spring-boot': '2.2.13.RELEASE',  'zonky-postgres': 'default'],
                    [name: '6.1.4',  flyway: '6.1.4',   'flyway-test': '6.1.0',    spring: '5.2.12.RELEASE',  'spring-boot': '2.2.13.RELEASE',  'zonky-postgres': 'default'],
                    [name: '6.3.3',  flyway: '6.3.3',   'flyway-test': '6.3.3',    spring: '5.2.22.RELEASE',  'spring-boot': '2.2.13.RELEASE',  'zonky-postgres': 'default'],
                    [name: '6.5.7',  flyway: '6.5.7',   'flyway-test': '6.4.0',    spring: '5.2.22.RELEASE',  'spring-boot': '2.2.13.RELEASE',  'zonky-postgres': 'default'],
                    [name: '7.6.0',  flyway: '7.6.0',   'flyway-test': '7.0.0',    spring: '5.3.13',          'spring-boot': '2.4.13',          'zonky-postgres': 'default'],
                    [name: '7.15.0', flyway: '7.15.0',  'flyway-test': '7.0.0',    spring: '5.3.27',          'spring-boot': '2.5.15',          'zonky-postgres': 'default'],
                    [name: '8.0.5',  flyway: '8.0.5',   'flyway-test': '7.0.0',    spring: '5.3.27',          'spring-boot': '2.6.15',          'zonky-postgres': 'default'],
                    [name: '8.5.13', flyway: '8.5.13',  'flyway-test': '7.0.0',    spring: '5.3.31',          'spring-boot': '2.7.18',          'zonky-postgres': 'default'],
                    [name: '9.0.4',  flyway: '9.0.4',   'flyway-test': '7.0.0',    spring: '5.3.31',          'spring-boot': '2.7.18',          'zonky-postgres': 'default'],
                    [name: '9.8.3',  flyway: '9.8.3',   'flyway-test': '7.0.0',    spring: '5.3.31',          'spring-boot': '2.7.18',          'zonky-postgres': 'default'],
                    [name: 'no_sb',  flyway: 'default', 'flyway-test': 'default',                                                               'zonky-postgres': 'default']
            ]],
            [name: 'liquibase', versions: [
                    [name: '3.5.5',  liquibase: '3.5.5',  spring: '4.3.30.RELEASE',  'spring-boot': '1.5.22.RELEASE'],
                    [name: '3.6.3',  liquibase: '3.6.3',  spring: '5.1.20.RELEASE',  'spring-boot': '2.1.18.RELEASE'],
                    [name: '3.7.0',  liquibase: '3.7.0',  spring: '5.1.20.RELEASE',  'spring-boot': '2.1.18.RELEASE'],
                    [name: '3.8.9',  liquibase: '3.8.9',  spring: '5.2.22.RELEASE',  'spring-boot': '2.2.13.RELEASE'],
                    [name: '3.9.0',  liquibase: '3.9.0',  spring: '5.2.22.RELEASE',  'spring-boot': '2.2.13.RELEASE'],
                    [name: '3.10.3', liquibase: '3.10.3', spring: '5.3.13',          'spring-boot': '2.4.13'],
                    [name: '4.4.3',  liquibase: '4.4.3',  spring: '5.3.27',          'spring-boot': '2.5.15'],
                    [name: '4.5.0',  liquibase: '4.5.0',  spring: '5.3.27',          'spring-boot': '2.6.15'],
                    [name: '4.9.1',  liquibase: '4.9.1',  spring: '5.3.31',          'spring-boot': '2.7.18'],
                    [name: 'no_sb',  liquibase: 'default']
            ]],
            [name: 'postgres', versions: [
                    [name: '12',  postgres: '12.22',  'zonky-postgres': '12.22.0',  opentable: 'default',  yandex: 'default'],
                    [name: '13',  postgres: '13.18',  'zonky-postgres': '13.18.0',  opentable: 'default',  yandex: 'default'],
                    [name: '14',  postgres: '14.15',  'zonky-postgres': '14.15.0',  opentable: 'default',  yandex: 'default'],
                    [name: '15',  postgres: '15.10',  'zonky-postgres': '15.10.0',  opentable: 'default',  yandex: 'default'],
                    [name: '16',  postgres: '16.6',   'zonky-postgres': '16.6.0',   opentable: 'default',  yandex: 'default'],
                    [name: '17',  postgres: '17.2',   'zonky-postgres': '17.2.0',   opentable: 'default',  yandex: 'default']
            ]],
            [name: 'mssql', versions: [
                    [name: '2017',  'mssql': '2017-latest',  'mssql-driver': 'default'],
                    [name: '2019',  'mssql': '2019-latest',  'mssql-driver': 'default'],
                    [name: '2022',  'mssql': '2022-latest',  'mssql-driver': 'default']
            ]],
            [name: 'mysql', versions: [
                    [name: '5.7',  'mysql': '5.7',  'mysql-driver': 'default'],
                    [name: '8.2',  'mysql': '8.2',  'mysql-driver': 'default']
            ]],
            [name: 'mariadb', versions: [
                    [name: '10.2',  'mariadb': '10.2',  'mariadb-driver': '2.7.7'],
                    [name: '11.3',  'mariadb': '11.3',  'mariadb-driver': 'default']
            ]],
            [name: 'h2', versions: [
                    [name: '1.3.176',  'h2': '1.3.176'],
                    [name: '1.4.200',  'h2': '1.4.200'],
                    [name: '2.0.206',  'h2': '2.0.206'],
                    [name: '2.1.214',  'h2': '2.1.214'],
                    [name: '2.2.224',  'h2': '2.2.224']
            ]],
            [name: 'hsqldb', versions: [
                    [name: '2.3.6',  'hsqldb': '2.3.6'],
                    [name: '2.4.1',  'hsqldb': '2.4.1'],
                    [name: '2.5.2',  'hsqldb': '2.5.2']
            ]],
            [name: 'derby', versions: [
                    [name: '10.13.1.1',  'derby': '10.13.1.1'],
                    [name: '10.14.2.0',  'derby': '10.14.2.0']
            ]]
    ]
}

if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) {
    testSuites.find { it.name == 'hsqldb' }.versions << [name: '2.7.1',  'hsqldb': '2.7.1']
}
if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_9)) {
    testSuites.find { it.name == 'derby' }.versions << [name: '10.15.2.0',  'derby': '10.15.2.0']
}
if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
    testSuites.find { it.name == 'derby' }.versions << [name: '10.16.1.1',  'derby': '10.16.1.1']

    testSuites.find { it.name == 'flyway' }.versions += [
            [name: '9.9.0',   flyway: '9.9.0',   'flyway-test': '9.5.0',    spring: '6.0.14',  'spring-boot': '3.0.13',  'zonky-postgres': 'default'],
            [name: '9.16.3',  flyway: '9.16.3',  'flyway-test': '9.5.0',    spring: '6.0.21',  'spring-boot': '3.1.12',  'zonky-postgres': 'default'],
            [name: '9.22.3',  flyway: '9.22.3',  'flyway-test': '9.5.0',    spring: '6.1.15',   'spring-boot': '3.2.12',   'zonky-postgres': 'default'],
            [name: '10.10.0',  flyway: '10.10.0',  'flyway-test': '10.0.0',   spring: '6.1.15',   'spring-boot': '3.3.6',   'zonky-postgres': 'default'],
            [name: '10.20.1', flyway: '10.20.1',  'flyway-test': '10.0.0',   spring: '6.2.0',   'spring-boot': '3.4.0',   'zonky-postgres': 'default'],
            [name: '11.0.0', flyway: '11.0.0',  'flyway-test': '10.0.0',   spring: '6.2.0',   'spring-boot': '3.4.0',   'zonky-postgres': 'default']
    ]

    testSuites.find { it.name == 'liquibase' }.versions += [
            [name: '4.17.2',  liquibase: '4.17.2',  spring: '6.0.14',  'spring-boot': '3.0.13'],
            [name: '4.20.0',  liquibase: '4.20.0',  spring: '6.0.21',  'spring-boot': '3.1.12'],
            [name: '4.24.0',  liquibase: '4.24.0',  spring: '6.1.15',   'spring-boot': '3.2.12'],
            [name: '4.27.0',  liquibase: '4.27.0',  spring: '6.1.15',   'spring-boot': '3.3.6'],
            [name: '4.29.2',  liquibase: '4.29.2',  spring: '6.2.0',   'spring-boot': '3.4.0']
    ]
}

allprojects {
    group 'io.zonky.test'
}

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'com.github.johnrengelman.shadow'

    sourceCompatibility = 1.8

    repositories {
        mavenCentral()
    }

    tasks.withType(GenerateModuleMetadata) {
        enabled = false
    }

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

    tasks.withType(Javadoc) {
        options.encoding = 'UTF-8'
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

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

    publishing {
        publications {
            mavenJava(MavenPublication) { publication ->
                groupId = project.group
                artifactId = project.name
                version = project.version

                from components.java
                artifact sourcesJar
                artifact javadocJar

                if (project.name == 'embedded-database-spring-test') {
                    artifact shadowJar
                }

                pom {
                    name = project.name
                    description = 'A library for creating isolated embedded databases for Spring-powered integration tests.'
                    url = 'https://github.com/zonkyio/embedded-database-spring-test'

                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }

                    developers {
                        developer {
                            name = 'Tomas Vanek'
                            email = 'tomix26@gmail.com'
                        }
                        developer {
                            name = 'Zonky Developers'
                            email = 'developers@zonky.cz'
                        }
                    }

                    scm {
                        connection = 'scm:git:git://github.com/zonkyio/embedded-database-spring-test.git'
                        developerConnection = 'scm:git:ssh://github.com:zonkyio/embedded-database-spring-test.git'
                        url = 'https://github.com/zonkyio/embedded-database-spring-test/tree/master'
                    }
                }
            }
        }

        repositories {
            maven {
                def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
                def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
                url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username ossrhUsername
                    password ossrhPassword
                }
            }
        }
    }

    signing {
        required { gradle.taskGraph.hasTask("publishMavenJavaPublicationToMavenRepository") }

        def signingKey = findProperty("signingKey")
        def signingKeyId = findProperty("signingKeyId")
        def signingPassword = findProperty("signingPassword")
        useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)

        sign publishing.publications.mavenJava
    }

    release {
        tagTemplate = 'v${version}'
        versionPatterns = [
            // increments the minor version: "1.0.0-SNAPSHOT" => "1.1.0-SNAPSHOT"
            /(\d+)\.\d+(([^\d\.].*)?$)/: { Matcher m, Project p -> m.replaceAll("${(m[0][1] as int) + 1}.0${m[0][2]}") }
        ]
        git {
            requireBranch = '^(master|\\d+\\.\\d+\\.x)$'
        }
    }
}

project(':embedded-database-spring-test-autoconfigure') {
    shadowJar {
        enabled = false
    }
}

project(':embedded-database-spring-test') {

    configurations {
        optImplementation
    }

    dependencies {
        api project(':embedded-database-spring-test-autoconfigure')

        api 'org.testcontainers:postgresql:1.18.3'
        api 'org.testcontainers:mssqlserver:1.18.3'
        api 'org.testcontainers:mysql:1.18.3'
        api 'org.testcontainers:mariadb:1.18.3'

        optImplementation 'io.zonky.test:embedded-postgres:2.1.0'
        optImplementation 'com.opentable.components:otj-pg-embedded:0.13.4'
        optImplementation 'ru.yandex.qatools.embed:postgresql-embedded:2.10'

        optImplementation 'org.postgresql:postgresql:42.7.3'
        optImplementation 'com.microsoft.sqlserver:mssql-jdbc:11.2.0.jre8'
        optImplementation 'mysql:mysql-connector-java:8.0.30'
        optImplementation 'org.mariadb.jdbc:mariadb-java-client:3.1.0'
        optImplementation 'com.h2database:h2:2.1.214'
        optImplementation 'org.hsqldb:hsqldb:2.5.2'
        optImplementation 'org.apache.derby:derby:10.14.2.0'
        optImplementation 'org.apache.derby:derbytools:10.14.2.0'

        optImplementation 'org.flywaydb:flyway-core:9.8.3'
        optImplementation 'org.flywaydb.flyway-test-extensions:flyway-spring-test:7.0.0'
        optImplementation('org.springframework.boot:spring-boot-starter-test:2.7.18') {
            exclude group: 'org.mockito'
        }
        optImplementation 'org.liquibase:liquibase-core:3.5.5'

        api 'org.springframework:spring-context:5.3.31'
        api 'org.springframework:spring-test:5.3.31'

        optImplementation 'com.google.guava:guava:24.1.1-jre'

        api('com.cedarsoftware:java-util:1.68.0') {
            exclude group: 'org.apache.logging.log4j'
        }

        testImplementation 'org.springframework:spring-jdbc:5.3.31'
        testImplementation 'ch.qos.logback:logback-classic:1.2.11'
        testImplementation 'org.mockito:mockito-core:3.12.4'
        testImplementation 'org.assertj:assertj-core:3.23.1'
        testImplementation 'com.zaxxer:HikariCP:4.0.3'
    }

    configurations {
        compileClasspath.extendsFrom(optImplementation)
        runtimeClasspath.extendsFrom(optImplementation)
        testCompileClasspath.extendsFrom(optImplementation)
        testRuntimeClasspath.extendsFrom(optImplementation)
    }

//    // TODO: override spring versions
//    configurations.all {
//        resolutionStrategy.eachDependency { details ->
//            if (details.requested.group == 'org.springframework') {
//                details.useVersion "5.3.23"
//            }
//            if (details.requested.group == 'org.springframework.boot') {
//                details.useVersion "2.7.5"
//            }
//        }
//    }

    configurations {
        testSuites.each { suite ->
            suite.versions.each { version ->
                "testRuntimeClasspath_${suite.name}_${version.name}" {
                    extendsFrom testRuntimeClasspath

                    if (version.flyway != null && (version.flyway.startsWith('10.') || version.flyway.startsWith('11.'))) {
                        dependencies.add(project.dependencies.create("org.flywaydb:flyway-database-postgresql:${version.flyway}"))
                    }

                    resolutionStrategy {

                        eachDependency { details ->
                            if (details.requested.group == 'junit') {
                                details.useVersion "4.12"
                            }
                        }

                        if (version.spring == 'none') { // mandatory dependencies must be explicitly excluded
                            exclude group: 'org.springframework'
                        } else if (version.spring != null) {
                            eachDependency { details ->
                                if (details.requested.group == 'org.springframework') {
                                    details.useVersion "${version.spring}"
                                }
                            }
                        }

                        if (version['spring-boot'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.springframework.boot'
                        } else if (version['spring-boot'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.springframework.boot') {
                                    details.useVersion "${version['spring-boot']}"
                                }
                            }
                        }

                        if (version.flyway == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.flywaydb', module: 'flyway-core'
                        } else if (version.flyway != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.flywaydb' && details.requested.name == 'flyway-core') {
                                    details.useVersion "${version.flyway}"
                                }
                            }
                        }

                        if (version['flyway-test'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.flywaydb.flyway-test-extensions'
                        } else if (version['flyway-test'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.flywaydb.flyway-test-extensions') {
                                    details.useVersion "${version['flyway-test']}"
                                }
                            }
                        }

                        if (version.liquibase == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.liquibase', module: 'liquibase-core'
                        } else if (version.liquibase != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.liquibase' && details.requested.name == 'liquibase-core') {
                                    details.useVersion "${version.liquibase}"
                                }
                            }
                        }

                        if (version['zonky-postgres'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'io.zonky.test.postgres'
                        } else if (version['zonky-postgres'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'io.zonky.test.postgres') {
                                    details.useVersion "${version['zonky-postgres']}"
                                }
                            }
                        }

                        if (version.opentable == null) { // optional dependencies are implicitly excluded
                            exclude group: 'com.opentable.components', module: 'otj-pg-embedded'
                        } else if (version.opentable != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'com.opentable.components' && details.requested.name == 'otj-pg-embedded') {
                                    details.useVersion "${version.opentable}"
                                }
                            }
                        }

                        if (version.yandex == null) { // optional dependencies are implicitly excluded
                            exclude group: 'ru.yandex.qatools.embed', module: 'postgresql-embedded'
                        } else if (version.yandex != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'ru.yandex.qatools.embed' && details.requested.name == 'postgresql-embedded') {
                                    details.useVersion "${version.yandex}"
                                }
                            }
                        }

                        if (version['mssql-driver'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'com.microsoft.sqlserver', module: 'mssql-jdbc'
                        } else if (version['mssql-driver'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'com.microsoft.sqlserver' && details.requested.name == 'mssql-jdbc') {
                                    details.useVersion "${version['mssql-driver']}"
                                }
                            }
                        }

                        if (version['mysql-driver'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'mysql', module: 'mysql-connector-java'
                        } else if (version['mysql-driver'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'mysql' && details.requested.name == 'mysql-connector-java') {
                                    details.useVersion "${version['mysql-driver']}"
                                }
                            }
                        }

                        if (version['mariadb-driver'] == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.mariadb.jdbc', module: 'mariadb-java-client'
                        } else if (version['mariadb-driver'] != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.mariadb.jdbc' && details.requested.name == 'mariadb-java-client') {
                                    details.useVersion "${version['mariadb-driver']}"
                                }
                            }
                        }

                        if (version.h2 == null) { // optional dependencies are implicitly excluded
                            exclude group: 'com.h2database', module: 'h2'
                        } else if (version.h2 != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'com.h2database' && details.requested.name == 'h2') {
                                    details.useVersion "${version.h2}"
                                }
                            }
                        }

                        if (version.hsqldb == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.hsqldb', module: 'hsqldb'
                        } else if (version.hsqldb != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.hsqldb' && details.requested.name == 'hsqldb') {
                                    details.useVersion "${version.hsqldb}"
                                }
                            }
                        }

                        if (version.derby == null) { // optional dependencies are implicitly excluded
                            exclude group: 'org.apache.derby'
                        } else if (version.derby != 'default') {
                            eachDependency { details ->
                                if (details.requested.group == 'org.apache.derby') {
                                    details.useVersion "${version.derby}"
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    shadowJar {
        archiveClassifier.set('')

        dependencies {
            include(dependency('com.google.guava:guava'))
        }

        relocate 'com.google.common', 'io.zonky.test.db.shaded.com.google.common'
        minimize()
    }

    jar {
        enabled = false
        dependsOn shadowJar
    }

    test {
        classpath -= configurations.testRuntimeClasspath
        classpath += configurations."testRuntimeClasspath_default_suite"

        useJUnit {
            excludeCategories 'io.zonky.test.category.SpringTestSuite'
            excludeCategories 'io.zonky.test.category.FlywayTestSuite'
            excludeCategories 'io.zonky.test.category.LiquibaseTestSuite'
            excludeCategories 'io.zonky.test.category.PostgresTestSuite'
            excludeCategories 'io.zonky.test.category.MSSQLTestSuite'
            excludeCategories 'io.zonky.test.category.MySQLTestSuite'
            excludeCategories 'io.zonky.test.category.MariaDBTestSuite'
            excludeCategories 'io.zonky.test.category.H2TestSuite'
            excludeCategories 'io.zonky.test.category.HSQLTestSuite'
            excludeCategories 'io.zonky.test.category.DerbyTestSuite'
        }
    }

    testSuites.tail().each { suite ->
        suite.versions.each { version ->
            task "test_${suite.name}_${version.name}"(type: Test, group: 'verification') {
                dependsOn jar

                classpath -= configurations.testRuntimeClasspath
                classpath += configurations."testRuntimeClasspath_${suite.name}_${version.name}"

                if (version.postgres) {
                    environment 'ZONKY_TEST_DATABASE_POSTGRES_YANDEX-PROVIDER_POSTGRES-VERSION', "${version.postgres}-1"
                    environment 'ZONKY_TEST_DATABASE_POSTGRES_DOCKER_IMAGE', "postgres:${version.postgres}-alpine"
                }
                if (version.mssql) {
                    environment 'ZONKY_TEST_DATABASE_MSSQL_DOCKER_IMAGE', "mcr.microsoft.com/mssql/server:${version.mssql}"
                }
                if (version.mysql) {
                    environment 'ZONKY_TEST_DATABASE_MYSQL_DOCKER_IMAGE', "mysql:${version.mysql}"
                }
                if (version.mariadb) {
                    environment 'ZONKY_TEST_DATABASE_MARIADB_DOCKER_IMAGE', "mariadb:${version.mariadb}"
                }

                useJUnit {
                    if (suite.name == 'spring') {
                        includeCategories 'io.zonky.test.category.SpringTestSuite'
                    } else if (suite.name == 'flyway') {
                        includeCategories 'io.zonky.test.category.FlywayTestSuite'
                    } else if (suite.name == 'liquibase') {
                        includeCategories 'io.zonky.test.category.LiquibaseTestSuite'
                    } else if (suite.name == 'postgres') {
                        includeCategories 'io.zonky.test.category.PostgresTestSuite'
                    } else if (suite.name == 'mssql') {
                        includeCategories 'io.zonky.test.category.MSSQLTestSuite'
                    } else if (suite.name == 'mysql') {
                        includeCategories 'io.zonky.test.category.MySQLTestSuite'
                    } else if (suite.name == 'mariadb') {
                        includeCategories 'io.zonky.test.category.MariaDBTestSuite'
                    } else if (suite.name == 'h2') {
                        includeCategories 'io.zonky.test.category.H2TestSuite'
                    } else if (suite.name == 'hsqldb') {
                        includeCategories 'io.zonky.test.category.HSQLTestSuite'
                    } else if (suite.name == 'derby') {
                        includeCategories 'io.zonky.test.category.DerbyTestSuite'
                    }
                }
            }
            check.dependsOn("test_${suite.name}_${version.name}")
        }
    }

    tasks.withType(Test) {
        testLogging {
            showStandardStreams = true
            showStackTraces = true
            exceptionFormat = 'full'
        }
    }
}

task updateReadmeVersion() {
    doLast {
        def version = project.version.toString()
        ant.replaceregexp(file: 'README.md',
                match: '(?<=<artifactId>embedded-database-spring-test</artifactId>\\n\\s{4,12})<version>\\d+\\.\\d+\\.\\d+</version>',
                replace: "<version>$version</version>", flags: 'g')
    }
}

// workaround for https://github.com/researchgate/gradle-release/issues/186
task build(group: 'build') {
    subprojects.each {
        dependsOn "${it.path}:build"
    }
}

runBuildTasks.dependsOn updateReadmeVersion

afterReleaseBuild {
    subprojects.each {
        dependsOn "${it.path}:publishMavenJavaPublicationToMavenRepository"
    }
}

// TODO: disable test tasks
//gradle.taskGraph.whenReady { graph ->
//    graph.allTasks.findAll { it.name ==~ /test.*/ }*.enabled = false
//}