deprecate: Raise deprecation levels of API property setters (#2209)

* deprecate: Raise deprecation levels of API property setters

The properties useNestedTransactions, defaultFetchSize, and defaultIsolationLevel
have deprecated setters since around version 0.35.1, since they were moved to DatabaseConfig
builder and only left in for testing.

DatabaseTestsBase methods have been refactored to accept a configuration parameter
so that withTables() for example can easily pass these properties to TestDB.connect()
as a builder.

The deprecation level of the properties has been raised to ERROR.

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Database.kt

@@ -24,7 +24,7 @@ class Database private constructor(
 ) {
     /** Whether nested transaction blocks are configured to act like top-level transactions. */
     var useNestedTransactions: Boolean = config.useNestedTransactions
-        @Deprecated("Use DatabaseConfig to define the useNestedTransactions")
+        @Deprecated("Use DatabaseConfig to define the useNestedTransactions", level = DeprecationLevel.ERROR)
         @TestOnly
         set
 
@@ -79,7 +79,7 @@ class Database private constructor(
     var defaultFetchSize: Int? = config.defaultFetchSize
         private set
 
-    @Deprecated("Use DatabaseConfig to define the defaultFetchSize")
+    @Deprecated("Use DatabaseConfig to define the defaultFetchSize", level = DeprecationLevel.ERROR)
     @TestOnly
     fun defaultFetchSize(size: Int): Database {
         defaultFetchSize = size

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/transactions/ThreadLocalTransactionManager.kt

@@ -76,7 +76,7 @@ class ThreadLocalTransactionManager(
             return field
         }
 
-        @Deprecated("Use DatabaseConfig to define the defaultIsolationLevel")
+        @Deprecated("Use DatabaseConfig to define the defaultIsolationLevel", level = DeprecationLevel.ERROR)
         @TestOnly
         set
 

exposed-tests/src/main/kotlin/org/jetbrains/exposed/sql/tests/DatabaseTestsBase.kt

@@ -1,6 +1,11 @@
 package org.jetbrains.exposed.sql.tests
 
-import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.DatabaseConfig
+import org.jetbrains.exposed.sql.Key
+import org.jetbrains.exposed.sql.Schema
+import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.Table
+import org.jetbrains.exposed.sql.Transaction
 import org.jetbrains.exposed.sql.statements.StatementInterceptor
 import org.jetbrains.exposed.sql.transactions.inTopLevelTransaction
 import org.jetbrains.exposed.sql.transactions.nullableTransactionScope
@@ -53,10 +58,13 @@ abstract class DatabaseTestsBase {
     @Parameterized.Parameter(2)
     lateinit var testName: String
 
-    fun withDb(dbSettings: TestDB, statement: Transaction.(TestDB) -> Unit) {
+    fun withDb(dbSettings: TestDB, configure: (DatabaseConfig.Builder.() -> Unit)? = null, statement: Transaction.(TestDB) -> Unit) {
         Assume.assumeTrue(dialect == dbSettings)
 
-        if (dbSettings !in registeredOnShutdown) {
+        val unregistered = dbSettings !in registeredOnShutdown
+        val newConfiguration = configure != null && !unregistered
+
+        if (unregistered) {
             dbSettings.beforeConnection()
             Runtime.getRuntime().addShutdownHook(
                 thread(false) {
@@ -65,19 +73,33 @@ abstract class DatabaseTestsBase {
                 }
             )
             registeredOnShutdown += dbSettings
-            dbSettings.db = dbSettings.connect()
+            dbSettings.db = dbSettings.connect(configure ?: {})
         }
 
+        val registeredDb = dbSettings.db!!
+        if (newConfiguration) {
+            dbSettings.db = dbSettings.connect(configure ?: {})
+        }
         val database = dbSettings.db!!
         transaction(database.transactionManager.defaultIsolationLevel, db = database) {
             maxAttempts = 1
             registerInterceptor(CurrentTestDBInterceptor)
             currentTestDB = dbSettings
             statement(dbSettings)
         }
+
+        // revert any new configuration to not be carried over to the next test in suite
+        if (configure != null) {
+            dbSettings.db = registeredDb
+        }
     }
 
-    fun withDb(db: Collection<TestDB>? = null, excludeSettings: Collection<TestDB> = emptyList(), statement: Transaction.(TestDB) -> Unit) {
+    fun withDb(
+        db: Collection<TestDB>? = null,
+        excludeSettings: Collection<TestDB> = emptyList(),
+        configure: (DatabaseConfig.Builder.() -> Unit)? = null,
+        statement: Transaction.(TestDB) -> Unit
+    ) {
         if (db != null && dialect !in db) {
             Assume.assumeFalse(true)
             return
@@ -93,13 +115,18 @@ abstract class DatabaseTestsBase {
             return
         }
 
-        withDb(dialect, statement)
+        withDb(dialect, configure, statement)
     }
 
-    fun withTables(excludeSettings: Collection<TestDB>, vararg tables: Table, statement: Transaction.(TestDB) -> Unit) {
+    fun withTables(
+        excludeSettings: Collection<TestDB>,
+        vararg tables: Table,
+        configure: (DatabaseConfig.Builder.() -> Unit)? = null,
+        statement: Transaction.(TestDB) -> Unit
+    ) {
         Assume.assumeFalse(dialect in excludeSettings)
 
-        withDb(dialect) {
+        withDb(dialect, configure = configure) {
             try {
                 SchemaUtils.drop(*tables)
             } catch (_: Throwable) {
@@ -124,7 +151,12 @@ abstract class DatabaseTestsBase {
         }
     }
 
-    fun withSchemas(excludeSettings: List<TestDB>, vararg schemas: Schema, statement: Transaction.() -> Unit) {
+    fun withSchemas(
+        excludeSettings: List<TestDB>,
+        vararg schemas: Schema,
+        configure: (DatabaseConfig.Builder.() -> Unit)? = null,
+        statement: Transaction.() -> Unit
+    ) {
         if (dialect !in TestDB.enabledDialects()) {
             Assume.assumeFalse(true)
             return
@@ -135,7 +167,7 @@ abstract class DatabaseTestsBase {
             return
         }
 
-        withDb(dialect) {
+        withDb(dialect, configure) {
             if (currentDialectTest.supportsCreateSchema) {
                 SchemaUtils.createSchema(*schemas)
                 try {
@@ -150,12 +182,12 @@ abstract class DatabaseTestsBase {
         }
     }
 
-    fun withTables(vararg tables: Table, statement: Transaction.(TestDB) -> Unit) {
-        withTables(excludeSettings = emptyList(), tables = tables, statement = statement)
+    fun withTables(vararg tables: Table, configure: (DatabaseConfig.Builder.() -> Unit)? = null, statement: Transaction.(TestDB) -> Unit) {
+        withTables(excludeSettings = emptyList(), tables = tables, configure = configure, statement = statement)
     }
 
-    fun withSchemas(vararg schemas: Schema, statement: Transaction.() -> Unit) {
-        withSchemas(excludeSettings = emptyList(), schemas = schemas, statement = statement)
+    fun withSchemas(vararg schemas: Schema, configure: (DatabaseConfig.Builder.() -> Unit)? = null, statement: Transaction.() -> Unit) {
+        withSchemas(excludeSettings = emptyList(), schemas = schemas, configure = configure, statement = statement)
     }
 
     fun addIfNotExistsIfSupported() = if (currentDialectTest.supportsIfNotExists) {

exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/NestedTransactionsTest.kt

@@ -25,41 +25,36 @@ class NestedTransactionsTest : DatabaseTestsBase() {
 
     @Test
     fun testNestedTransactions() {
-        withTables(DMLTestsData.Cities) {
-            try {
-                db.useNestedTransactions = true
-                assertTrue(DMLTestsData.Cities.selectAll().empty())
+        withTables(DMLTestsData.Cities, configure = { useNestedTransactions = true }) {
+            assertTrue(DMLTestsData.Cities.selectAll().empty())
 
-                DMLTestsData.Cities.insert {
-                    it[DMLTestsData.Cities.name] = "city1"
-                }
+            DMLTestsData.Cities.insert {
+                it[name] = "city1"
+            }
+
+            assertEquals(1L, DMLTestsData.Cities.selectAll().count())
 
-                assertEquals(1L, DMLTestsData.Cities.selectAll().count())
+            assertEqualLists(listOf("city1"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
 
-                assertEqualLists(listOf("city1"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
+            transaction {
+                DMLTestsData.Cities.insert {
+                    it[name] = "city2"
+                }
+                assertEqualLists(listOf("city1", "city2"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
 
                 transaction {
                     DMLTestsData.Cities.insert {
-                        it[DMLTestsData.Cities.name] = "city2"
-                    }
-                    assertEqualLists(listOf("city1", "city2"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
-
-                    transaction {
-                        DMLTestsData.Cities.insert {
-                            it[DMLTestsData.Cities.name] = "city3"
-                        }
-                        assertEqualLists(listOf("city1", "city2", "city3"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
+                        it[name] = "city3"
                     }
-
                     assertEqualLists(listOf("city1", "city2", "city3"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
-
-                    rollback()
                 }
 
-                assertEqualLists(listOf("city1"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
-            } finally {
-                db.useNestedTransactions = false
+                assertEqualLists(listOf("city1", "city2", "city3"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
+
+                rollback()
             }
+
+            assertEqualLists(listOf("city1"), DMLTestsData.Cities.selectAll().map { it[DMLTestsData.Cities.name] })
         }
     }
 

exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/RollbackTransactionTest.kt

@@ -15,14 +15,14 @@ class RollbackTransactionTest : DatabaseTestsBase() {
         withTables(RollbackTable) {
             inTopLevelTransaction(db.transactionManager.defaultIsolationLevel) {
                 maxAttempts = 1
-                RollbackTable.insert { it[RollbackTable.value] = "before-dummy" }
+                RollbackTable.insert { it[value] = "before-dummy" }
                 transaction {
                     assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
-                    RollbackTable.insert { it[RollbackTable.value] = "inner-dummy" }
+                    RollbackTable.insert { it[value] = "inner-dummy" }
                 }
                 assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
                 assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "inner-dummy" }.count())
-                RollbackTable.insert { it[RollbackTable.value] = "after-dummy" }
+                RollbackTable.insert { it[value] = "after-dummy" }
                 assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "after-dummy" }.count())
                 rollback()
             }
@@ -34,29 +34,24 @@ class RollbackTransactionTest : DatabaseTestsBase() {
 
     @Test
     fun testRollbackWithSavepoints() {
-        withTables(RollbackTable) {
-            try {
-                db.useNestedTransactions = true
-                inTopLevelTransaction(db.transactionManager.defaultIsolationLevel) {
-                    maxAttempts = 1
-                    RollbackTable.insert { it[RollbackTable.value] = "before-dummy" }
-                    transaction {
-                        assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
-                        RollbackTable.insert { it[RollbackTable.value] = "inner-dummy" }
-                        rollback()
-                    }
+        withTables(RollbackTable, configure = { useNestedTransactions = true }) {
+            inTopLevelTransaction(db.transactionManager.defaultIsolationLevel) {
+                maxAttempts = 1
+                RollbackTable.insert { it[value] = "before-dummy" }
+                transaction {
                     assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
-                    assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "inner-dummy" }.count())
-                    RollbackTable.insert { it[RollbackTable.value] = "after-dummy" }
-                    assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "after-dummy" }.count())
+                    RollbackTable.insert { it[value] = "inner-dummy" }
                     rollback()
                 }
-                assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
+                assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
                 assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "inner-dummy" }.count())
-                assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "after-dummy" }.count())
-            } finally {
-                db.useNestedTransactions = false
+                RollbackTable.insert { it[value] = "after-dummy" }
+                assertEquals(1L, RollbackTable.selectAll().where { RollbackTable.value eq "after-dummy" }.count())
+                rollback()
             }
+            assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "before-dummy" }.count())
+            assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "inner-dummy" }.count())
+            assertEquals(0L, RollbackTable.selectAll().where { RollbackTable.value eq "after-dummy" }.count())
         }
     }
 }

exposed-tests/src/test/kotlin/org/jetbrains/exposed/sql/tests/shared/dml/UpsertTests.kt

@@ -412,9 +412,7 @@ class UpsertTests : DatabaseTestsBase() {
             val losses = integer("losses")
         }
 
-        withTables(excludeSettings = TestDB.ALL_H2_V1, tester) {
-            db.useNestedTransactions = true
-
+        withTables(excludeSettings = TestDB.ALL_H2_V1, tester, configure = { useNestedTransactions = true }) {
             val itemA = "Item A"
             tester.upsert {
                 it[item] = itemA
@@ -456,8 +454,6 @@ class UpsertTests : DatabaseTestsBase() {
             assertEquals(insertCode, updateCode)
             assertEquals(insertGains, updateGains)
             assertNotEquals(insertLosses, updateLosses)
-
-            db.useNestedTransactions = false
         }
     }