build(deps): Bump Spring Framework to 7.0.1 and Spring Boot to 4.0.0

- Temporarily disable flaky tests to see if CI/CD successfully builds

Author: bog-walk

exposed-spring-boot-starter/src/main/kotlin/org/jetbrains/exposed/v1/spring/boot/DatabaseInitializer.kt

@@ -23,8 +23,10 @@ import java.util.regex.Pattern
  * @property applicationContext The Spring ApplicationContext container responsible for managing beans.
  * @property excludedPackages List of packages to exclude, so that their contained tables are not auto-created.
  */
-open class DatabaseInitializer(private val applicationContext: ApplicationContext, private val excludedPackages: List<String>) :
-    ApplicationRunner, Ordered {
+open class DatabaseInitializer(
+    private val applicationContext: ApplicationContext,
+    private val excludedPackages: List<String>
+) : ApplicationRunner, Ordered {
     override fun getOrder(): Int = DATABASE_INITIALIZER_ORDER
 
     companion object {
@@ -34,7 +36,7 @@ open class DatabaseInitializer(private val applicationContext: ApplicationContex
     private val logger = LoggerFactory.getLogger(javaClass)
 
     @Transactional
-    override fun run(args: ApplicationArguments?) {
+    override fun run(args: ApplicationArguments) {
         val exposedTables = discoverExposedTables(applicationContext, excludedPackages)
         logger.info("Schema generation for tables '{}'", exposedTables.map { it.tableName })
 

exposed-spring-boot-starter/src/main/kotlin/org/jetbrains/exposed/v1/spring/boot/autoconfigure/ExposedAutoConfiguration.kt

@@ -8,7 +8,7 @@ import org.springframework.beans.factory.annotation.Value
 import org.springframework.boot.autoconfigure.AutoConfiguration
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
-import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
+import org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration
 import org.springframework.context.ApplicationContext
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Primary

exposed-spring-boot-starter/src/test/kotlin/org/jetbrains/exposed/v1/spring/boot/Application.kt

@@ -2,7 +2,7 @@ package org.jetbrains.exposed.v1.spring.boot
 
 import org.springframework.boot.SpringApplication
 import org.springframework.boot.autoconfigure.SpringBootApplication
-import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
+import org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration
 import org.springframework.scheduling.annotation.EnableAsync
 
 @EnableAsync

exposed-spring-boot-starter/src/test/kotlin/org/jetbrains/exposed/v1/spring/boot/DatabaseInitializerTest.kt

@@ -9,6 +9,7 @@ import org.jetbrains.exposed.v1.spring.boot.tables.ignore.IgnoreTable
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.DefaultApplicationArguments
 import org.springframework.boot.test.context.SpringBootTest
 import org.springframework.context.ApplicationContext
 
@@ -26,9 +27,12 @@ open class DatabaseInitializerTest {
         Assertions.assertThrows(ExposedSQLException::class.java) {
             Database.connect("jdbc:h2:mem:test-spring", user = "sa", driver = "org.h2.Driver")
             transaction {
-                DatabaseInitializer(applicationContext, listOf("org.jetbrains.exposed.v1.spring.boot.tables.ignore")).run(
-                    null
+                val noArgs = DefaultApplicationArguments()
+                DatabaseInitializer(
+                    applicationContext,
+                    listOf("org.jetbrains.exposed.v1.spring.boot.tables.ignore")
                 )
+                    .run(noArgs)
                 Assertions.assertEquals(0L, TestTable.selectAll().count())
                 IgnoreTable.selectAll().count()
             }

exposed-spring-boot-starter/src/test/kotlin/org/jetbrains/exposed/v1/spring/boot/autoconfigure/ExposedAutoConfigurationTest.kt

@@ -14,7 +14,7 @@ import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.NoSuchBeanDefinitionException
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.autoconfigure.AutoConfigurations
-import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
+import org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration
 import org.springframework.boot.test.context.SpringBootTest
 import org.springframework.boot.test.context.TestConfiguration
 import org.springframework.boot.test.context.runner.ApplicationContextRunner

gradle/libs.versions.toml

@@ -31,10 +31,10 @@ oracle-r2dbc = "1.3.0"
 postgresql-r2dbc = "1.1.1.RELEASE"
 sqlserver-r2dbc = "1.0.3.RELEASE"
 
-springFramework = "6.2.14"
-springBoot = "3.5.8"
+springFramework = "7.0.1"
+springBoot = "4.0.0"
 
-spring-security-crypto = "6.2.1"
+spring-security-crypto = "7.0.0"
 joda-time = "2.14.0"
 junit5 = "5.14.1"
 junit6 = "6.0.1"

spring-transaction/src/main/kotlin/org/jetbrains/exposed/v1/spring/transaction/ExposedSpringTransactionAttributeSource.kt

@@ -25,7 +25,7 @@ class ExposedSpringTransactionAttributeSource(
             val rules = attr.rollbackRules.toMutableList()
             rollbackExceptions.forEach { exception ->
                 val containsException = rules.any {
-                    it is RollbackRuleAttribute && it.exceptionName == exception.name
+                    it.exceptionName == exception.name
                 }
                 if (!containsException) {
                     rules.add(RollbackRuleAttribute(exception))

spring-transaction/src/test/kotlin/org/jetbrains/exposed/v1/spring/transaction/ExposedTransactionManagerTest.kt

@@ -11,9 +11,8 @@ import org.jetbrains.exposed.v1.jdbc.transactions.transaction
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.RepeatedTest
 import org.springframework.test.annotation.Commit
-import org.springframework.test.annotation.Repeat
 import org.springframework.transaction.IllegalTransactionStateException
 import org.springframework.transaction.TransactionDefinition
 import org.springframework.transaction.annotation.Isolation
@@ -44,19 +43,17 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
         }
     }
 
-    @Test
+    @RepeatedTest(5)
     @Transactional
     @Commit
-    @Repeat(5)
     open fun testConnection() {
         T1.insertRandom()
         assertEquals(1, T1.selectAll().count())
     }
 
-    @Test
+    @RepeatedTest(5)
     @Transactional
     @Commit
-    @Repeat(5)
     open fun testConnection2() {
         val rnd = Random().nextInt().toString()
         T1.insert {
@@ -65,8 +62,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
         assertEquals(rnd, T1.selectAll().single()[T1.c1])
     }
 
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Commit
     open fun testConnectionCombineWithExposedTransaction() {
         transaction {
@@ -83,8 +79,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
         }
     }
 
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Commit
     @Transactional
     open fun testConnectionCombineWithExposedTransaction2() {
@@ -104,8 +99,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.NESTED
      * Execute within a nested transaction if a current transaction exists, behave like REQUIRED otherwise.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testConnectionWithNestedTransactionCommit() {
         T1.insertRandom()
@@ -121,8 +115,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.NESTED with inner roll-back
      * The nested transaction will be roll-back only inner transaction when the transaction marks as rollback.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testConnectionWithNestedTransactionInnerRollback() {
         T1.insertRandom()
@@ -139,8 +132,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.NESTED with outer roll-back
      * The nested transaction will be roll-back entire transaction when the transaction marks as rollback.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     fun testConnectionWithNestedTransactionOuterRollback() {
         transactionManager.execute {
             T1.insertRandom()
@@ -163,8 +155,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.REQUIRES_NEW
      * Create a new transaction, and suspend the current transaction if one exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testConnectionWithRequiresNew() {
         T1.insertRandom()
@@ -182,8 +173,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * The inner transaction will be roll-back only inner transaction when the transaction marks as rollback.
      * And since isolation level is READ_COMMITTED, the inner transaction can't see the changes of outer transaction.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     fun testConnectionWithRequiresNewWithInnerTransactionRollback() {
         transactionManager.execute {
             T1.insertRandom()
@@ -205,8 +195,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.NEVER
      * Execute non-transactionally, throw an exception if a transaction exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional(propagation = Propagation.NEVER)
     open fun testPropagationNever() {
         assertFailsWith<IllegalStateException> { // Should Be "No transaction exist"
@@ -218,8 +207,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.NEVER
      * Throw an exception cause outer transaction exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testPropagationNeverWithExistingTransaction() {
         assertFailsWith<IllegalTransactionStateException> {
@@ -234,8 +222,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.MANDATORY
      * Support a current transaction, throw an exception if none exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testPropagationMandatoryWithTransaction() {
         T1.insertRandom()
@@ -248,8 +235,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.MANDATORY
      * Throw an exception cause no transaction exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     open fun testPropagationMandatoryWithoutTransaction() {
         assertFailsWith<IllegalTransactionStateException> {
             transactionManager.execute(TransactionDefinition.PROPAGATION_MANDATORY) {
@@ -262,8 +248,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.SUPPORTS
      * Support a current transaction, execute non-transactionally if none exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional
     open fun testPropagationSupportWithTransaction() {
         T1.insertRandom()
@@ -276,8 +261,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Propagation.SUPPORTS
      * Execute non-transactionally if none exists.
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     open fun testPropagationSupportWithoutTransaction() {
         transactionManager.execute(TransactionDefinition.PROPAGATION_SUPPORTS) {
             assertFailsWith<IllegalStateException> { // Should Be "No transaction exist"
@@ -289,8 +273,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
     /**
      * Test for Isolation Level
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     @Transactional(isolation = Isolation.READ_COMMITTED)
     open fun testIsolationLevelReadUncommitted() {
         assertTransactionIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED)
@@ -307,8 +290,7 @@ open class ExposedTransactionManagerTest : SpringTransactionTestBase() {
      * Test for Timeout
      * Execute with query timeout
      */
-    @Test
-    @Repeat(5)
+    @RepeatedTest(5)
     open fun testTimeout() {
         transactionManager.execute(timeout = 1) {
             try {

spring-transaction/src/test/kotlin/org/jetbrains/exposed/v1/spring/transaction/SpringMultiContainerTransactionTest.kt

@@ -162,12 +162,14 @@ open class Orders {
 
     open fun findAll(): List<ResultRow> = Order.selectAll().toList()
 
+    // NOTE: qualifier names must be left in
     open fun findAllWithExposedTrxBlock() = org.jetbrains.exposed.v1.jdbc.transactions.transaction { findAll() }
 
     open fun create() = Order.insertAndGetId {
         it[buyer] = 123
     }.value
 
+    // NOTE: qualifier names must be left in
     open fun createWithExposedTrxBlock() = org.jetbrains.exposed.v1.jdbc.transactions.transaction { create() }
 
     open fun init() {