# Dockerの動作確認
if command -v docker &> /dev/null; then
    docker --version
    docker run --rm hello-world
else
    echo "警告: Dockerが見つかりません。Testcontainersを使用するにはDockerのインストールが必要です。"
    echo "インストール方法: https://docs.docker.com/get-docker/"
    exit 1
fi

# JDKバージョン確認（17以上推奨）
if command -v java &> /dev/null; then
    java --version
else
    echo "警告: Javaが見つかりません。JDK 17以上をインストールしてください。"
fi

# Gradleバージョン確認（8.x推奨）
if [ -f "./gradlew" ]; then
    ./gradlew --version
else
    echo "警告: gradlewが見つかりません。プロジェクトルートで実行してください。"
fi

// build.gradle.kts
dependencies {
    // Testcontainers BOM でバージョンを統一
    testImplementation(platform("org.testcontainers:testcontainers-bom:1.20.4"))
    testImplementation("org.testcontainers:testcontainers")
    testImplementation("org.testcontainers:postgresql")
    testImplementation("org.testcontainers:junit-jupiter")

    // JUnit Jupiter
    testImplementation("org.junit.jupiter:junit-jupiter:5.11.4")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    // PostgreSQL JDBCドライバ
    testImplementation("org.postgresql:postgresql:42.7.4")

    // Flyway（マイグレーション管理）
    testImplementation("org.flywaydb:flyway-core:10.20.1")
    testImplementation("org.flywaydb:flyway-database-postgresql:10.20.1")

    // HikariCP（コネクションプール）
    testImplementation("com.zaxxer:HikariCP:5.1.0")
}

tasks.test {
    useJUnitPlatform()
    // Dockerが利用できない環境ではTestcontainersテストをスキップ
    val dockerAvailable = try {
        Runtime.getRuntime().exec(arrayOf("docker", "info")).waitFor() == 0
    } catch (e: Exception) {
        false
    }
    if (!dockerAvailable) {
        systemProperty("org.testcontainers.checks.disable", "true")
        exclude("**/*ContainerTest*", "**/*IntegrationTest*")
        logger.warn("警告: Dockerが見つからないため、Testcontainersを使用するテストをスキップします。")
    }
}

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.testcontainers</groupId>
      <artifactId>testcontainers-bom</artifactId>
      <version>1.20.4</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>postgresql</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

src/
├── main/
│   └── kotlin/
│       └── com/example/
│           ├── domain/
│           │   └── User.kt
│           └── repository/
│               └── UserRepository.kt
└── test/
    ├── kotlin/
    │   └── com/example/
    │       ├── support/
    │       │   ├── DatabaseContainer.kt   # シングルトンコンテナ
    │       │   ├── TestDatabase.kt        # ThreadLocal管理・DB複製
    │       │   └── TestDatabaseExtension.kt # JUnit Extension
    │       └── repository/
    │           ├── UserRepositoryTest.kt
    │           └── OrderRepositoryTest.kt
    └── resources/
        ├── db/migration/
        │   ├── V1__create_users.sql
        │   └── V2__create_orders.sql
        └── junit-platform.properties

-- V1__create_users.sql
CREATE TABLE users (
    id         BIGSERIAL PRIMARY KEY,
    email      VARCHAR(255) NOT NULL UNIQUE,
    name       VARCHAR(100) NOT NULL,
    profile    JSONB,
    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
);

-- V2__create_orders.sql
CREATE TABLE orders (
    id         BIGSERIAL PRIMARY KEY,
    user_id    BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    status     VARCHAR(50) NOT NULL DEFAULT 'pending',
    amount     NUMERIC(12, 2) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
    CONSTRAINT chk_amount_positive CHECK (amount > 0)
);

import org.junit.jupiter.api.Test
import org.testcontainers.containers.PostgreSQLContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
import java.sql.DriverManager
import kotlin.test.assertEquals

@Testcontainers
class MinimalContainerTest {

    @Container
    val postgres = PostgreSQLContainer<Nothing>("postgres:18-alpine")

    @Test
    fun `PostgreSQLコンテナに接続してクエリを実行できる`() {
        DriverManager.getConnection(
            postgres.jdbcUrl,
            postgres.username,
            postgres.password
        ).use { conn ->
            val rs = conn.createStatement().executeQuery("SELECT 1")
            rs.next()
            assertEquals(1, rs.getInt(1))
        }
    }
}

@Testcontainers
class ContainerLifecycleTest {

    companion object {
        // クラス全体で1個のコンテナを共有（推奨）
        @Container
        @JvmStatic
        val postgres = PostgreSQLContainer<Nothing>("postgres:18-alpine")
    }

    @Test
    fun `test1`() { /* 同じコンテナを使用 */ }

    @Test
    fun `test2`() { /* 同じコンテナを使用 */ }
}

// ❌ 避けるべき書き方
PostgreSQLContainer<Nothing>("postgres:latest")

// ✅ 推奨する書き方
PostgreSQLContainer<Nothing>("postgres:18-alpine")

PostgreSQLContainer<Nothing>("postgres:18-alpine")
    .waitingFor(
        Wait.forListeningPort().withStartupTimeout(Duration.ofSeconds(120))
    )

// src/test/kotlin/com/example/support/DatabaseContainer.kt
import org.testcontainers.containers.PostgreSQLContainer

object DatabaseContainer {

    val instance: PostgreSQLContainer<Nothing> by lazy {
        PostgreSQLContainer<Nothing>("postgres:18-alpine")
            .withDatabaseName("test_master")
            .withUsername("test")
            .withPassword("test")
            .withCommand(
                "postgres",
                "-c", "fsync=off",
                "-c", "full_page_writes=off",
                "-c", "synchronous_commit=off"
            )
            .also { it.start() }
    }
}

object DatabaseContainer {

    val instance: PostgreSQLContainer<Nothing> by lazy {
        PostgreSQLContainer<Nothing>("postgres:18-alpine")
            // ...（省略）
            .also { container ->
                container.start()
                createTemplateDatabase(container)
            }
    }

    private fun createTemplateDatabase(container: PostgreSQLContainer<Nothing>) {
        // masterに接続してtemplateデータベースを作成
        getConnection(container, "test_master").use { conn ->
            conn.createStatement().execute(
                "CREATE DATABASE test_db_template"
            )
        }

        // templateデータベースにFlywayでMigrationを実行
        Flyway.configure()
            .dataSource(
                container.jdbcUrl.replace("/test_master", "/test_db_template"),
                container.username,
                container.password
            )
            .load()
            .migrate()  // これが1回だけ実行される
    }
}

.withCommand(
    "postgres",
    "-c", "fsync=off",                // ディスクへの同期を無効化
    "-c", "full_page_writes=off",     // ページ書き込みを最小化
    "-c", "synchronous_commit=off",   // コミットの同期待ちを無効化
    "-c", "max_connections=200"       // 並列テスト用に接続数を増やす
)

fun createDatabaseFromTemplate(
    conn: Connection,
    dbName: String,
    templateName: String = "test_db_template"
) {
    // TEMPLATE指定時、ソースDBへの接続が残っていると失敗する
    // → 事前に全接続を切断する
    conn.createStatement().execute("""
        SELECT pg_terminate_backend(pid)
        FROM pg_stat_activity
        WHERE datname = '$templateName' AND pid <> pg_backend_pid()
    """)

    conn.createStatement().execute(
        "CREATE DATABASE $dbName TEMPLATE $templateName"
    )
}

# src/test/resources/junit-platform.properties

# 並列実行を有効化
junit.jupiter.execution.parallel.enabled=true

# デフォルト（メソッドレベル）は順次実行
junit.jupiter.execution.parallel.mode.default=same_thread

# クラスレベルは並列実行
junit.jupiter.execution.parallel.mode.classes.default=concurrent

# 並列度の設定（固定値またはCPUコア数に応じた動的設定）
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=1.0

並列度 ≤ max_connections ÷ pool_size_per_thread

// そのテストクラスだけをシングルスレッドで実行
@Execution(ExecutionMode.SAME_THREAD)
class SequentialTest { ... }

// 共有リソースへの排他アクセスを宣言
@ResourceLock(value = "shared-resource", mode = ResourceAccessMode.READ_WRITE)
class ResourceLockTest { ... }

テストクラスA（Thread-1）
  ├── テスト1: setup() → test_db_1001 複製・初期化（初回: ~50ms）
  ├── テスト2: setup() → test_db_1001 TRUNCATE+再投入（2回目以降: ~27ms）
  └── テスト3: setup() → test_db_1001 TRUNCATE+再投入

テストクラスB（Thread-2）
  ├── テスト1: setup() → test_db_1002 複製・初期化（初回: ~50ms）
  └── テスト2: setup() → test_db_1002 TRUNCATE+再投入

// src/test/kotlin/com/example/support/TestDatabase.kt
import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import java.sql.Connection

class TestDatabase private constructor(
    private val container: PostgreSQLContainer<Nothing>
) {
    companion object {
        private val threadDatabaseCache = ThreadLocal<ThreadDatabaseState>()
        private val dbCounter = java.util.concurrent.atomic.AtomicInteger(1000)

        fun setup(container: PostgreSQLContainer<Nothing>): HikariDataSource {
            val cached = threadDatabaseCache.get()

            return if (cached != null) {
                // 2回目以降: TRUNCATEとデータ再投入のみ
                resetData(cached.dataSource)
                cached.dataSource
            } else {
                // 初回: Templateから新しいDBを複製
                val dbName = "test_db_${dbCounter.getAndIncrement()}"
                val newDataSource = createDatabaseFromTemplate(container, dbName)
                threadDatabaseCache.set(ThreadDatabaseState(dbName, newDataSource))
                newDataSource
            }
        }

        private fun createDatabaseFromTemplate(
            container: PostgreSQLContainer<Nothing>,
            dbName: String
        ): HikariDataSource {
            // masterに接続してDB複製
            getMasterConnection(container).use { conn ->
                // template使用中の接続を切断
                conn.createStatement().execute("""
                    SELECT pg_terminate_backend(pid)
                    FROM pg_stat_activity
                    WHERE datname = 'test_db_template'
                      AND pid <> pg_backend_pid()
                """)
                conn.createStatement().execute(
                    "CREATE DATABASE $dbName TEMPLATE test_db_template"
                )
            }

            // 新しいDBへの接続プールを作成
            val config = HikariConfig().apply {
                jdbcUrl = container.jdbcUrl.replace("/test_master", "/$dbName")
                username = container.username
                password = container.password
                maximumPoolSize = 5
                minimumIdle = 1
            }
            return HikariDataSource(config)
        }

        private fun resetData(dataSource: HikariDataSource) {
            dataSource.connection.use { conn ->
                // 全テーブルをTRUNCATE（順序を気にせずCASCADEで一括）
                conn.createStatement().execute("""
                    TRUNCATE TABLE orders, users RESTART IDENTITY CASCADE
                """)
                // 初期データを再投入
                reinsertInitialData(conn)
            }
        }

        private fun reinsertInitialData(conn: Connection) {
            // pg_dumpから抽出した初期データのSQL群を実行
            InitialDataHolder.insertStatements.forEach { sql ->
                conn.createStatement().execute(sql)
            }
        }
    }

    data class ThreadDatabaseState(
        val dbName: String,
        val dataSource: HikariDataSource
    )
}

// src/test/kotlin/com/example/support/TestDatabaseExtension.kt
import org.junit.jupiter.api.extension.BeforeEachCallback
import org.junit.jupiter.api.extension.ExtensionContext

class TestDatabaseExtension : BeforeEachCallback {

    override fun beforeEach(context: ExtensionContext) {
        val dataSource = TestDatabase.setup(DatabaseContainer.instance)
        // ExtensionContextのStoreにDataSourceを保存し、テストから参照できるようにする
        context.getStore(ExtensionContext.Namespace.GLOBAL)
            .put("dataSource", dataSource)
    }
}

@ExtendWith(TestDatabaseExtension::class)
class UserRepositoryTest {

    @Test
    fun `ユーザーを登録できる`(context: ExtensionContext) {
        val dataSource = context.getStore(ExtensionContext.Namespace.GLOBAL)
            .get("dataSource") as HikariDataSource
        // ...テストコード
    }
}

-- 全テーブルを1文で、シーケンスもリセット
TRUNCATE TABLE orders, users RESTART IDENTITY CASCADE;

// pg_dumpの出力から必要な行だけを抽出
fun extractInitialData(dumpOutput: String): List<String> {
    return dumpOutput.lineSequence()
        .filter { line ->
            line.startsWith("INSERT INTO ") ||
            line.startsWith("SELECT pg_catalog.setval(")
        }
        .toList()
}

pg_dump \
  --host=localhost \
  --port=5432 \
  --username=test \
  --data-only \
  --column-inserts \
  --no-privileges \
  test_db_template > initial_data.sql

@SpringBootTest
@Testcontainers
class UserServiceIntegrationTest {

    companion object {
        @Container
        @ServiceConnection
        @JvmStatic
        val postgres = PostgreSQLContainer<Nothing>("postgres:18-alpine")
    }

    @Autowired
    private lateinit var userService: UserService

    @Test
    fun `ユーザーの重複登録は例外になる`() {
        userService.register("test@example.com", "Alice")

        // 2回目の登録で例外が発生することを検証
        // MockではDBのUNIQUE制約を通らないため検証不可能
        assertThrows<DuplicateUserException> {
            userService.register("test@example.com", "Bob")
        }
    }
}

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class UserRepositoryJpaTest {

    companion object {
        @Container
        @ServiceConnection
        @JvmStatic
        val postgres = PostgreSQLContainer<Nothing>("postgres:18-alpine")
    }
}

@ExtendWith(TestDatabaseExtension::class)
class UserRepositoryTest {

    @Test
    fun `UNIQUE制約違反はDataIntegrityViolationExceptionになる`(ctx: ExtensionContext) {
        val repo = UserRepository(getDataSource(ctx))
        repo.save(User(email = "alice@example.com", name = "Alice"))

        // 同じemailで2件目を登録しようとすると例外になることを検証
        // Mockではこの検証が書けない（Mockは制約を知らないから）
        assertThrows<DataIntegrityViolationException> {
            repo.save(User(email = "alice@example.com", name = "Alice2"))
        }
    }

    @Test
    fun `外部キー制約でユーザー削除時にorderもCASCADE削除される`(ctx: ExtensionContext) {
        val repo = UserRepository(getDataSource(ctx))
        val orderRepo = OrderRepository(getDataSource(ctx))

        val user = repo.save(User(email = "bob@example.com", name = "Bob"))
        orderRepo.save(Order(userId = user.id, amount = 1000.0))

        repo.delete(user.id)

        // CASCADE削除されていることを確認
        assertEquals(0, orderRepo.countByUserId(user.id))
    }

    @Test
    fun `JSONBカラムへの保存と検索ができる`(ctx: ExtensionContext) {
        val repo = UserRepository(getDataSource(ctx))
        val profile = mapOf("age" to 30, "city" to "Tokyo")
        repo.save(User(email = "carol@example.com", name = "Carol", profile = profile))

        // JSONB演算子を使ったクエリの動作確認
        val results = repo.findByProfileCity("Tokyo")
        assertEquals(1, results.size)
    }
}

override fun beforeEach(context: ExtensionContext) {
    val dataSource = TestDatabase.setup(DatabaseContainer.instance)
    val dbName = DatabaseContainer.currentDbName()

    logger.info(
        "Thread: ${Thread.currentThread().name} | DB: $dbName | Test: ${context.displayName}"
    )
}

Thread: ForkJoinPool-1-worker-1 | DB: test_db_1001 | Test: UserRepositoryTest
Thread: ForkJoinPool-1-worker-2 | DB: test_db_1002 | Test: OrderRepositoryTest
Thread: ForkJoinPool-1-worker-3 | DB: test_db_1003 | Test: ProductRepositoryTest

# .github/workflows/test.yml
name: Test

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest  # DockerデーモンがデフォルトでAvailable

    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'

      - name: Cache Gradle packages
        uses: actions/cache@v4
        with:
          path: ~/.gradle/caches
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}

      - name: Cache Docker images
        uses: actions/cache@v4
        with:
          path: /tmp/.docker-cache
          key: docker-${{ hashFiles('**/build.gradle.kts') }}

      - name: Run tests
        run: ./gradlew test --parallel
        env:
          TESTCONTAINERS_REUSE_ENABLE: "false"  # CIではReuse無効

PostgreSQLContainer<Nothing>("postgres:18-alpine")
    .apply {
        // 環境変数で切り替える
        if (System.getenv("CI") == null) {
            withReuse(true)
        }
    }

PostgreSQLContainer<Nothing>("postgres:18-alpine")
    .withLogConsumer(
        Slf4jLogConsumer(LoggerFactory.getLogger("postgres-container"))
    )

max_connections ≥ 並列度 × スレッドあたりのプールサイズ + 管理用接続数（10程度）