tighten tests further.

src/dialect/mssql/mssql-driver.ts

@@ -100,12 +100,6 @@ export class MssqlDriver implements Driver {
     await connection.rollbackTransaction(savepointName)
   }
 
-  async releaseSavepoint(): Promise<void> {
-    throw new Error(
-      'MS SQL Server (mssql) does not support releasing savepoints',
-    )
-  }
-
   async releaseConnection(connection: MssqlConnection): Promise<void> {
     await connection[PRIVATE_RELEASE_METHOD]()
     this.#pool.release(connection)

src/driver/dummy-driver.ts

@@ -65,6 +65,18 @@ export class DummyDriver implements Driver {
   async destroy(): Promise<void> {
     // Nothing to do here.
   }
+
+  async releaseSavepoint(): Promise<void> {
+    // Nothing to do here.
+  }
+
+  async rollbackToSavepoint(): Promise<void> {
+    // Nothing to do here.
+  }
+
+  async savepoint(): Promise<void> {
+    // Nothing to do here.
+  }
 }
 
 class DummyConnection implements DatabaseConnection {

src/driver/runtime-driver.ts

@@ -95,7 +95,7 @@ export class RuntimeDriver implements Driver {
       return this.#driver.savepoint(connection, savepointName, compileQuery)
     }
 
-    throw new Error('savepoints are not supported by this driver')
+    throw new Error('The `savepoint` method is not supported by this driver')
   }
 
   rollbackToSavepoint(
@@ -111,7 +111,9 @@ export class RuntimeDriver implements Driver {
       )
     }
 
-    throw new Error('savepoints are not supported by this driver')
+    throw new Error(
+      'The `rollbackToSavepoint` method is not supported by this driver',
+    )
   }
 
   releaseSavepoint(
@@ -127,7 +129,9 @@ export class RuntimeDriver implements Driver {
       )
     }
 
-    throw new Error('savepoints are not supported by this driver')
+    throw new Error(
+      'The `releaseSavepoint` method is not supported by this driver',
+    )
   }
 
   async destroy(): Promise<void> {

test/node/src/controlled-transaction.test.ts

@@ -1,6 +1,14 @@
 import * as sinon from 'sinon'
 import { Connection } from 'tedious'
-import { CompiledQuery, IsolationLevel, Kysely } from '../../../'
+import {
+  CompiledQuery,
+  ControlledTransaction,
+  Driver,
+  DummyDriver,
+  IsolationLevel,
+  Kysely,
+  SqliteDialect,
+} from '../../../'
 import {
   DIALECTS,
   Database,
@@ -501,14 +509,30 @@ for (const dialect of DIALECTS) {
       })
     }
 
+    if (dialect === 'mssql') {
+      it('should throw an error when trying to release a savepoint as it is not supported', async () => {
+        const trx = await ctx.db.startTransaction().execute()
+
+        await expect(
+          trx.releaseSavepoint('foo' as never).execute(),
+        ).to.be.rejectedWith(
+          'The `releaseSavepoint` method is not supported by this driver',
+        )
+
+        await trx.rollback().execute()
+      })
+    }
+
     it('should throw an error when trying to execute a query after the transaction has been committed', async () => {
       const trx = await ctx.db.startTransaction().execute()
 
       await insertSomething(trx)
 
       await trx.commit().execute()
 
-      await expect(insertSomethingElse(trx)).to.be.rejected
+      await expect(insertSomethingElse(trx)).to.be.rejectedWith(
+        'Transaction is already committed',
+      )
     })
 
     it('should throw an error when trying to execute a query after the transaction has been rolled back', async () => {
@@ -518,29 +542,88 @@ for (const dialect of DIALECTS) {
 
       await trx.rollback().execute()
 
-      await expect(insertSomethingElse(trx)).to.be.rejected
+      await expect(insertSomethingElse(trx)).to.be.rejectedWith(
+        'Transaction is already rolled back',
+      )
     })
   })
+}
 
-  async function insertSomething(db: Kysely<Database>) {
-    return await db
-      .insertInto('person')
-      .values({
-        first_name: 'Foo',
-        last_name: 'Barson',
-        gender: 'male',
-      })
-      .executeTakeFirstOrThrow()
-  }
-
-  async function insertSomethingElse(db: Kysely<Database>) {
-    return await db
-      .insertInto('person')
-      .values({
-        first_name: 'Fizz',
-        last_name: 'Buzzson',
-        gender: 'female',
-      })
-      .executeTakeFirstOrThrow()
-  }
+describe('custom dialect: controlled transaction', () => {
+  const db = new Kysely<Database>({
+    dialect: new (class extends SqliteDialect {
+      createDriver(): Driver {
+        const driver = class extends DummyDriver {}
+
+        // @ts-ignore
+        driver.prototype.releaseSavepoint = undefined
+        // @ts-ignore
+        driver.prototype.rollbackToSavepoint = undefined
+        // @ts-ignore
+        driver.prototype.savepoint = undefined
+
+        return new driver()
+      }
+      // @ts-ignore
+    })({}),
+  })
+  let trx: ControlledTransaction<Database>
+
+  before(async () => {
+    trx = await db.startTransaction().execute()
+  })
+
+  after(async () => {
+    await trx.rollback().execute()
+  })
+
+  it('should throw an error when trying to savepoint on a dialect that does not support it', async () => {
+    const trx = await db.startTransaction().execute()
+
+    await expect(trx.savepoint('foo').execute()).to.be.rejectedWith(
+      'The `savepoint` method is not supported by this driver',
+    )
+  })
+
+  it('should throw an error when trying to rollback to a savepoint on a dialect that does not support it', async () => {
+    const trx = await db.startTransaction().execute()
+
+    await expect(
+      trx.rollbackToSavepoint('foo' as never).execute(),
+    ).to.be.rejectedWith(
+      'The `rollbackToSavepoint` method is not supported by this driver',
+    )
+  })
+
+  it('should throw an error when trying to release a savepoint on a dialect that does not support it', async () => {
+    const trx = await db.startTransaction().execute()
+
+    await expect(
+      trx.releaseSavepoint('foo' as never).execute(),
+    ).to.be.rejectedWith(
+      'The `releaseSavepoint` method is not supported by this driver',
+    )
+  })
+})
+
+async function insertSomething(db: Kysely<Database>) {
+  return await db
+    .insertInto('person')
+    .values({
+      first_name: 'Foo',
+      last_name: 'Barson',
+      gender: 'male',
+    })
+    .executeTakeFirstOrThrow()
+}
+
+async function insertSomethingElse(db: Kysely<Database>) {
+  return await db
+    .insertInto('person')
+    .values({
+      first_name: 'Fizz',
+      last_name: 'Buzzson',
+      gender: 'female',
+    })
+    .executeTakeFirstOrThrow()
 }