build.gradle

import org.testcontainers.containers.PostgreSQLContainer
import org.gradle.api.services.BuildServiceParameters
import org.gradle.api.services.BuildService

buildscript {
    dependencies {
//      Required dependencies to start testcontainers and do the migration during the build.
        classpath libs.testcontainers.postgres
        classpath libs.flyway.postgresql
    }
}

plugins {
    id 'java-library'

//  Gradle plugins for jOOQ and Flyway.
    alias(libs.plugins.flyway)
    alias(libs.plugins.jooq)
}

repositories {
    mavenLocal()
    mavenCentral()
}

group = 'com.sergeylappo.testcontainers'
version = '1.0.0-SNAPSHOT'
description = 'tc-guide-working-with-jooq-flyway-using-testcontainers-gradle'

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

dependencies {
    implementation libs.bundles.spring.boot

//  Dependencies required for the application to use jooq and flyway in runtime.
    implementation libs.flyway.postgresql
    implementation libs.jooq.core

//  Your database driver
    runtimeOnly libs.postgresql
//  Database driver for the build time.
    jooqCodegen libs.postgresql

    testImplementation libs.bundles.spring.boot.test

//  Testcontainers dependencies for the test tasks.
    testImplementation libs.bundles.testcontainers
}

// Here we register service for providing our database during the build.
Provider<PostgresService> dbContainerProvider = project.getGradle()
        .getSharedServices()
        .registerIfAbsent("postgres", PostgresService.class, {})


tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    dependsOn jooqCodegen
}

tasks.withType(Javadoc).configureEach {
    options.encoding = 'UTF-8'
}

test {
    useJUnitPlatform()

//  This is only necessary if you want to reuse container for the tests.
    usesService dbContainerProvider
    doFirst {
        def dbContainer = dbContainerProvider.get().container
        systemProperty('spring.datasource.url', dbContainer.jdbcUrl)
        systemProperty('spring.datasource.username', dbContainer.username)
        systemProperty('spring.datasource.password', dbContainer.password)
    }
}

flywayMigrate {
//  We need access to our database during the build.
    usesService dbContainerProvider
//  Define location of the migrations.
    locations = ["filesystem:src/main/resources/db/migration"]
//  Flyway plugin won't define input files for us, so to follow Gradle convention define them.
    inputs.files(fileTree("src/main/resources/db/migration"))

    doFirst {
        def dbContainer = dbContainerProvider.get().container
//      Set up the flyway config.
        url = dbContainer.jdbcUrl
        user = dbContainer.username
        password = dbContainer.password
    }
}

afterEvaluate {
//  For jOOQ to run we always need for flyway to be completed before.
    jooqCodegen.dependsOn flywayMigrate
    jooqCodegen {
        doFirst {
            def dbContainer = dbContainerProvider.get().container
            jooq {
                configuration {
                    jdbc {
                        driver = "org.postgresql.Driver"
                        url = dbContainer.jdbcUrl
                        user = dbContainer.username
                        password = dbContainer.password
                    }
                }
            }
        }
    }
}

jooq {
//  jOOQ generation config
    configuration {
        logging = org.jooq.meta.jaxb.Logging.WARN
        generator {
            name = "org.jooq.codegen.DefaultGenerator"
            database {
                name = "org.jooq.meta.postgres.PostgresDatabase"
                includes = ".*"
                excludes = 'flyway_schema_history'
                inputSchema = 'public'
            }
            target {
                packageName = 'com.testcontainers.demo.jooq'
                directory = 'target/generated-sources/jooq'
            }
        }
    }
}

/**
 * Build service for providing database container.
 */
abstract class PostgresService implements BuildService<BuildServiceParameters.None>, AutoCloseable {
    private final PostgreSQLContainer container;

    PostgresService() {
//        Services are initialized lazily, on first request to them, so we start container immediately.
        container = new PostgreSQLContainer("postgres:16-alpine")
        container.start()
    }

    @Override
    void close() {
//        Ensure to stop container in the end
        container.stop()
    }

    PostgreSQLContainer getContainer() {
        return container
    }
}