Merge pull request #135 from driessamyn/dependabot/gradle/org.junit.jupiter-junit-jupiter-5.13.1

driessamyn · web-flow · commit fe749455d649 · 2025-06-15T17:24:28.000+01:00
build(deps): Bump org.junit.jupiter:junit-jupiter from 5.12.2 to 5.13.1
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/AbstractDbTests.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/AbstractDbTests.kt
@@ -6,8 +6,11 @@ import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Named.named
 import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.params.Parameter
+import org.junit.jupiter.params.ParameterizedClass
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.Arguments.arguments
+import org.junit.jupiter.params.provider.MethodSource
 import org.testcontainers.containers.JdbcDatabaseContainer
 import org.testcontainers.containers.MSSQLServerContainer
 import org.testcontainers.containers.MySQLContainer
@@ -21,10 +24,14 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.logging.Level
 import java.util.logging.Logger
 import kotlin.random.Random
-import kotlin.use
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@ParameterizedClass
+@MethodSource("databaseContainers")
 abstract class AbstractDbTests {
+    @Parameter
+    protected lateinit var connection: Connection
+
     companion object {
         init {
             Class.forName("org.sqlite.JDBC")
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/ExecuteTests.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/ExecuteTests.kt
@@ -5,16 +5,13 @@ import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.collections.shouldBeEmpty
 import io.kotest.matchers.shouldBe
 import net.samyn.kapper.internal.getDbFlavour
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import java.sql.Connection
+import org.junit.jupiter.api.Test
 import java.sql.SQLException
 import java.util.UUID
 
 class ExecuteTests : AbstractDbTests() {
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `SQL Insert single`(connection: Connection) {
+    @Test
+    fun `SQL Insert single`() {
         val supermanClone = superman.copy(id = UUID.randomUUID())
         val results =
             connection.execute(
@@ -44,9 +41,8 @@ class ExecuteTests : AbstractDbTests() {
             }
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `SQL Update single`(connection: Connection) {
+    @Test
+    fun `SQL Update single`() {
         val batmanClone = batman.copy(id = UUID.randomUUID())
         connection.createStatement().use { stmt ->
             stmt.execute(
@@ -81,9 +77,8 @@ class ExecuteTests : AbstractDbTests() {
             }
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `SQL Update multiple`(connection: Connection) {
+    @Test
+    fun `SQL Update multiple`() {
         val ids = listOf(UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID())
         val name = "foo-${UUID.randomUUID()}"
         connection.createStatement().use { stmt ->
@@ -105,9 +100,8 @@ class ExecuteTests : AbstractDbTests() {
         results.shouldBe(ids.size)
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `SQL Delete single`(connection: Connection) {
+    @Test
+    fun `SQL Delete single`() {
         val spidermanClone = spiderMan.copy(id = UUID.randomUUID())
         connection.createStatement().use { stmt ->
             stmt.execute(
@@ -136,9 +130,8 @@ class ExecuteTests : AbstractDbTests() {
             }
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `SQL Delete multiple`(connection: Connection) {
+    @Test
+    fun `SQL Delete multiple`() {
         val ids = listOf(UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID())
         val name = "bar-${UUID.randomUUID()}"
         connection.createStatement().use { stmt ->
@@ -159,9 +152,8 @@ class ExecuteTests : AbstractDbTests() {
         results.shouldBe(ids.size)
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `with TX completes`(connection: Connection) {
+    @Test
+    fun `with TX completes`() {
         connection.withTransaction {
             val results =
                 connection.execute(
@@ -184,9 +176,8 @@ class ExecuteTests : AbstractDbTests() {
         }
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `with TX rolls back`(connection: Connection) {
+    @Test
+    fun `with TX rolls back`() {
         val id = UUID.randomUUID()
         shouldThrow<SQLException> {
             connection.withTransaction {
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/QuerySingleTests.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/QuerySingleTests.kt
@@ -7,15 +7,12 @@ import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldContain
 import net.samyn.kapper.internal.DbFlavour
 import net.samyn.kapper.internal.getDbFlavour
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import java.sql.Connection
+import org.junit.jupiter.api.Test
 import java.sql.ResultSet
 
 class QuerySingleTests : AbstractDbTests() {
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `should query 1 heros`(connection: Connection) {
+    @Test
+    fun `should query 1 heros`() {
         val sql =
             if (DbFlavour.MSSQLSERVER == connection.getDbFlavour()) {
                 "SELECT TOP 1 * FROM super_heroes_$testId ORDER BY age DESC"
@@ -28,16 +25,14 @@ class QuerySingleTests : AbstractDbTests() {
         hero.shouldBe(superman)
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query hero with condition`(connection: Connection) {
+    @Test
+    fun `should query hero with condition`() {
         val hero = connection.querySingle<SuperHero>("SELECT * FROM super_heroes_$testId WHERE age > :age", "age" to 85)
         hero.shouldBe(superman)
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query specific columns`(connection: Connection) {
+    @Test
+    fun `should query specific columns`() {
         val hero =
             connection.querySingle<SuperHero>(
                 "SELECT id, name FROM super_heroes_$testId WHERE name = :name",
@@ -46,9 +41,8 @@ class QuerySingleTests : AbstractDbTests() {
         hero.shouldBe(SuperHero(superman.id, superman.name))
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should handle empty result set`(connection: Connection) {
+    @Test
+    fun `should handle empty result set`() {
         val hero =
             connection.querySingle<SuperHero>(
                 "SELECT * FROM super_heroes_$testId WHERE name = :name",
@@ -57,9 +51,8 @@ class QuerySingleTests : AbstractDbTests() {
         hero.shouldBeNull()
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should throw when larger than one result`(connection: Connection) {
+    @Test
+    fun `should throw when larger than one result`() {
         val ex =
             shouldThrow<KapperResultException> {
                 connection.querySingle<SuperHero>(
@@ -69,9 +62,8 @@ class QuerySingleTests : AbstractDbTests() {
         ex.message.shouldContain("3")
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query with multiple conditions`(connection: Connection) {
+    @Test
+    fun `should query with multiple conditions`() {
         val hero =
             connection.querySingle<SuperHero>(
                 "SELECT * FROM super_heroes_$testId WHERE age BETWEEN :fromAge AND :toAge",
@@ -81,9 +73,8 @@ class QuerySingleTests : AbstractDbTests() {
         hero.shouldBe(superman)
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `can use custom mapper`(connection: Connection) {
+    @Test
+    fun `can use custom mapper`() {
         val villain =
             connection.querySingle<Villain>(
                 "SELECT id, name FROM super_heroes_$testId WHERE name = :name",
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/QueryTests.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/QueryTests.kt
@@ -4,15 +4,12 @@ import io.kotest.matchers.collections.shouldBeEmpty
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.collections.shouldContainOnly
 import io.kotest.matchers.shouldBe
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import java.sql.Connection
+import org.junit.jupiter.api.Test
 import java.sql.ResultSet
 
 class QueryTests : AbstractDbTests() {
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query all heros`(connection: Connection) {
+    @Test
+    fun `should query all heros`() {
         val heroes = connection.query<SuperHero>("SELECT * FROM super_heroes_$testId")
         heroes.shouldContainExactlyInAnyOrder(
             superman,
@@ -21,19 +18,17 @@ class QueryTests : AbstractDbTests() {
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query heros with condition`(connection: Connection) {
+    @Test
+    fun `should query heros with condition`() {
         val heroes = connection.query<SuperHero>("SELECT * FROM super_heroes_$testId WHERE age > :age", "age" to 80)
         heroes.shouldContainExactlyInAnyOrder(
             superman,
             batman,
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query specific columns`(connection: Connection) {
+    @Test
+    fun `should query specific columns`() {
         val heroes =
             connection.query<SuperHero>(
                 "SELECT id, name FROM super_heroes_$testId WHERE name = :name",
@@ -44,9 +39,8 @@ class QueryTests : AbstractDbTests() {
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should handle empty result set`(connection: Connection) {
+    @Test
+    fun `should handle empty result set`() {
         val heroes =
             connection.query<SuperHero>(
                 "SELECT * FROM super_heroes_$testId WHERE name = :name",
@@ -55,9 +49,8 @@ class QueryTests : AbstractDbTests() {
         heroes.shouldBeEmpty()
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `should query with multiple conditions`(connection: Connection) {
+    @Test
+    fun `should query with multiple conditions`() {
         val heroes =
             connection.query<SuperHero>(
                 "SELECT * FROM super_heroes_$testId WHERE age BETWEEN :fromAge AND :toAge",
@@ -70,9 +63,8 @@ class QueryTests : AbstractDbTests() {
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `support field labels`(connection: Connection) {
+    @Test
+    fun `support field labels`() {
         data class SimpleClass(val superHeroName: String)
         val hero =
             connection.query<SimpleClass>(
@@ -84,9 +76,8 @@ class QueryTests : AbstractDbTests() {
         )
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `can use custom registered mapper`(connection: Connection) {
+    @Test
+    fun `can use custom registered mapper`() {
         data class SuperHero2(val name: String, val email: String? = null, val age: Int? = null)
 
         class SuperHeroMapper : Mapper<SuperHero2> {
@@ -110,9 +101,8 @@ class QueryTests : AbstractDbTests() {
         )
     }
 
-    @ParameterizedTest
-    @MethodSource("databaseContainers")
-    fun `can use custom mapper`(connection: Connection) {
+    @Test
+    fun `can use custom mapper`() {
         val villain =
             connection.query<Villain>(
                 "SELECT id, name FROM super_heroes_$testId WHERE name = :name",
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/SqlInjectionTest.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/SqlInjectionTest.kt
@@ -1,19 +1,15 @@
 package net.samyn.kapper
 
 import io.kotest.matchers.collections.shouldNotBeEmpty
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import java.sql.Connection
+import org.junit.jupiter.api.Test
 
 class SqlInjectionTest : AbstractDbTests() {
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `cannot inject SQL with parameter`(connection: Connection) {
+    @Test
+    fun `cannot inject SQL with parameter`() {
         connection.execute(
             "UPDATE super_heroes_$testId SET name = 'foo' WHERE name = :name",
             "name" to "bar; DROP TABLE super_heroes",
         )
-
         connection.query<SuperHero>("SELECT * FROM super_heroes_$testId").shouldNotBeEmpty()
     }
 }
diff --git a/core/src/integrationTest/kotlin/net/samyn/kapper/TypesTest.kt b/core/src/integrationTest/kotlin/net/samyn/kapper/TypesTest.kt
@@ -2,8 +2,7 @@ package net.samyn.kapper
 
 import io.kotest.matchers.shouldBe
 import net.samyn.kapper.internal.getDbFlavour
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
+import org.junit.jupiter.api.Test
 import java.sql.Connection
 import java.time.Instant
 import java.time.LocalDate
@@ -49,9 +48,8 @@ class TypesTest : AbstractDbTests() {
         }
     }
 
-    @ParameterizedTest()
-    @MethodSource("databaseContainers")
-    fun `can insert and retreive the same types`(connection: Connection) {
+    @Test
+    fun `can insert and retreive the same types`() {
         val testData = createTestObject()
         val result =
             connection.execute(
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -2,7 +2,7 @@
 dokka = "2.0.0"
 git-semver = "0.16.0"
 jmh = "1.37"
-junit-jupiter = "5.12.2"
+junit-jupiter = "5.13.1"
 kotest = "6.0.0.M4"
 kotlin = "2.1.21"
 kotlinx-coroutines = "1.10.2"
