chore: integrate Testcontainers for automatic Docker Compose management in integration tests

.github/workflows/gradle.yml

@@ -51,7 +51,6 @@ jobs:
       - uses: gradle/actions/setup-gradle@4d9f0ba0025fe599b4ebab900eb7f3a1d93ef4c2 # v5.0.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
-      - run: docker compose -f docker-compose.yml --profile app up --wait --build
       - run: "./gradlew integrationTest --continue"
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:

client/src/main/kotlin/hu/bsstudio/bssweb/config/DefaultFeignConfig.kt

@@ -6,10 +6,7 @@ import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 
 @Configuration
-class DefaultFeignConfig(
-    @param:Value("\${bss.client.username}") val username: String,
-    @param:Value("\${bss.client.password}") val password: String,
-) {
+class DefaultFeignConfig {
     @Bean
     fun interceptor() =
         RequestInterceptor { template ->

docker-compose.ci.yml

@@ -1,14 +1,14 @@
 services:
   app:
-    ports: !override
+    ports:
       - "8080"
   postgres:
-    ports: !override
+    ports:
       - "5432"
   mock-file-api:
-    ports: !override
+    ports:
       - "8080"
     volumes: []
   mock-oidc:
-    ports: !override
+    ports:
       - "5556"

integration/README.md

@@ -4,15 +4,33 @@ It stores the integration tests for the application.
 
 To run the integration tests, you need to have Docker installed on your machine.
 
-Testcontainers didn't have a clean way to start the compose file before all the tests.
-So it's required to start the compose file manually before running the tests.
-Each test will clear the database tables.
+The integration tests now use **Testcontainers with Docker Compose** to automatically start and configure the required services from your existing `docker-compose.yml`:
+- PostgreSQL database
+- WireMock servers for external API mocking (file-api and OIDC)
+
+The Docker Compose services are automatically started before the tests run and stopped after completion.
+Each test will clear the database tables to ensure test isolation.
 
 Each Integration test has to extend the `IntegrationTest` class.
 
 ```shell
-docker compose up -d
 ./gradlew integrationTest
-docker compose down
 ```
 
+## What's changed from manual Docker Compose
+
+- **Automatic lifecycle management**: Testcontainers automatically starts/stops your Docker Compose services
+- **Dynamic port mapping**: Tests use the actual exposed ports from Docker Compose
+- **Same service configuration**: Uses your existing `docker-compose.yml` exactly as configured
+- **Isolated test environment**: Each test run gets fresh containers
+- **No manual setup required**: No need to run `docker compose up/down` manually
+
+## Container Configuration
+
+The integration tests use your existing `docker-compose.yml` services:
+- **PostgreSQL 16.3**: Exact same configuration as your compose file
+- **WireMock 3.13.1**: File-api and OIDC mocks with the same stub mappings
+- **Automatic cleanup**: All compose services are removed after test completion
+
+This approach ensures your integration tests run against the exact same service configuration as your development and production environments.
+

integration/build.gradle.kts

@@ -13,4 +13,7 @@ dependencies {
     integrationTestImplementation("org.springframework.cloud:spring-cloud-starter-openfeign")
     integrationTestImplementation("org.springframework.boot:spring-boot-starter-data-jpa")
     integrationTestImplementation("org.springframework.boot:spring-boot-starter-json")
+    integrationTestImplementation("org.springframework.boot:spring-boot-testcontainers")
+    integrationTestImplementation("org.testcontainers:testcontainers")
+    integrationTestImplementation("org.testcontainers:junit-jupiter")
 }

integration/src/integrationTest/kotlin/hu/bsstudio/bssweb/IntegrationTest.kt

@@ -9,22 +9,45 @@ import hu.bsstudio.bssweb.video.repository.DetailedVideoRepository
 import hu.bsstudio.bssweb.videocrew.repository.VideoCrewRepository
 import org.junit.jupiter.api.BeforeEach
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.test.context.TestPropertySource
+import org.springframework.test.context.DynamicPropertyRegistry
+import org.springframework.test.context.DynamicPropertySource
 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig
+import org.testcontainers.containers.DockerComposeContainer
+import org.testcontainers.junit.jupiter.Container
+import org.testcontainers.junit.jupiter.Testcontainers
+import java.io.File
 
+@Testcontainers
 @SpringJUnitConfig(classes = [BssFeignConfig::class, DataConfig::class])
-@TestPropertySource(
-    properties = [
-        "bss.client.url=http://localhost:8080",
-        "bss.client.username=user",
-        "bss.client.password=password",
-        "spring.flyway.enabled=false",
-        "spring.datasource.url=jdbc:postgresql://localhost:5432/bss?currentSchema=private",
-        "spring.datasource.username=user",
-        "spring.datasource.password=password",
-    ],
-)
 open class IntegrationTest {
+    companion object {
+        @Container
+        @JvmStatic
+        val compose: DockerComposeContainer<*> =
+            DockerComposeContainer(File("../docker-compose.yml"), File("../docker-compose.ci.yml"))
+                .withExposedService("postgres", 5432)
+                .withExposedService("app", 8080)
+                .withOptions("--profile app")
+                .withBuild(true)
+
+        @DynamicPropertySource
+        @JvmStatic
+        fun configureProperties(registry: DynamicPropertyRegistry) {
+            val postgresHost = compose.getServiceHost("postgres", 5432)
+            val postgresPort = compose.getServicePort("postgres", 5432)
+            val appHost = compose.getServiceHost("app", 8080)
+            val appPort = compose.getServicePort("app", 8080)
+
+            registry.add("spring.datasource.url") {
+                "jdbc:postgresql://$postgresHost:$postgresPort/bss?currentSchema=private"
+            }
+            registry.add("spring.datasource.username") { "user" }
+            registry.add("spring.datasource.password") { "password" }
+            registry.add("spring.flyway.enabled") { "false" }
+            registry.add("bss.client.url") { "http://$appHost:$appPort" }
+        }
+    }
+
     @Autowired protected lateinit var eventRepository: DetailedEventRepository
 
     @Autowired protected lateinit var videoRepository: DetailedVideoRepository