diff --git a/README.md b/README.md
index 55e9a559..c2a6ca84 100644
--- a/README.md
+++ b/README.md
@@ -151,9 +151,9 @@ class RestaurantDemoSpec extends Specification with RestaurantDemoDatabaseFuncti
 
 ## Run Tests
 ```shell
+docker rm -f mongodb;
 docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest; 
 sbt +test; 
-docker rm -f mongodb;
 ```
 
 ## Supporters
diff --git a/docker.sh b/docker.sh
deleted file mode 100644
index 0b27b638..00000000
--- a/docker.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-docker rm -f mongodb;
-docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest;
\ No newline at end of file
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/CompactSpec.scala b/src/test/scala/dev/mongocamp/driver/mongodb/CompactSuite.scala
similarity index 97%
rename from src/test/scala/dev/mongocamp/driver/mongodb/CompactSpec.scala
rename to src/test/scala/dev/mongocamp/driver/mongodb/CompactSuite.scala
index 13301661..cf1d17c5 100644
--- a/src/test/scala/dev/mongocamp/driver/mongodb/CompactSpec.scala
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/CompactSuite.scala
@@ -9,7 +9,7 @@ import munit.FunSuite
 import java.text.SimpleDateFormat
 import java.util.Date
 
-class CompactSpec extends FunSuite {
+class CompactSuite extends FunSuite {
   val DateFormat = new SimpleDateFormat("yyyy-MM-dd")
   val From: Date = DateFormat.parse("2000-01-01")
 
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/DocumentIncludesSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/DocumentIncludesSuite.scala
new file mode 100644
index 00000000..c31406e5
--- /dev/null
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/DocumentIncludesSuite.scala
@@ -0,0 +1,81 @@
+package dev.mongocamp.driver.mongodb
+
+import dev.mongocamp.driver.DocumentIncludes
+import dev.mongocamp.driver.mongodb.database.DatabaseProvider
+import munit.FunSuite
+import org.mongodb.scala.Document
+import org.bson.types.ObjectId
+import org.apache.lucene.search.MatchAllDocsQuery
+
+class DocumentIncludesSuite extends FunSuite with DocumentIncludes {
+
+  test("mapToBson should convert Map to Bson") {
+    val map = Map("key" -> "value")
+    val bson = mapToBson(map)
+    assert(bson.isInstanceOf[Document])
+    assertEquals(bson.asInstanceOf[Document].getString("key"), "value")
+  }
+
+  test("luceneQueryBson should convert Lucene Query to Bson") {
+    val query = new MatchAllDocsQuery()
+    val bson = luceneQueryBson(query)
+    assert(bson.isInstanceOf[Document])
+  }
+
+  test("documentFromJavaMap should convert java.util.Map to Document") {
+    val javaMap = new java.util.HashMap[String, Any]()
+    javaMap.put("key", "value")
+    val document = documentFromJavaMap(javaMap)
+    assert(document.isInstanceOf[Document])
+    assertEquals(document.getString("key"), "value")
+  }
+
+  test("documentFromMutableMap should convert mutable.Map to Document") {
+    val mutableMap: collection.mutable.Map[String, Any] = collection.mutable.Map("key" -> "value")
+    val document = documentFromMutableMap(mutableMap)
+    assert(document.isInstanceOf[Document])
+    assertEquals(document.getString("key"), "value")
+  }
+
+  test("documentFromScalaMap should convert Map to Document") {
+    val map = Map("key" -> "value")
+    val document = documentFromScalaMap(map)
+    assert(document.isInstanceOf[Document])
+    assertEquals(document.getString("key"), "value")
+  }
+
+  test("documentFromDocument should convert org.bson.Document to Document") {
+    val bsonDoc = new org.bson.Document("key", "value")
+    val document = documentFromDocument(bsonDoc)
+    assert(document.isInstanceOf[Document])
+    assertEquals(document.getString("key"), "value")
+  }
+
+  test("mapFromDocument should convert Document to Map") {
+    val document = Document("key" -> "value")
+    val map = mapFromDocument(document)
+    assert(map.isInstanceOf[Map[_, _]])
+    assertEquals(map("key"), "value")
+  }
+
+  test("mapListFromDocuments should convert List of Documents to List of Maps") {
+    val documents = List(Document("key" -> "value"))
+    val mapList = mapListFromDocuments(documents)
+    assert(mapList.isInstanceOf[List[_]])
+    assertEquals(mapList.head("key"), "value")
+  }
+
+  test("stringToObjectId should convert String to ObjectId") {
+    val str = "507f1f77bcf86cd799439011"
+    val objectId = stringToObjectId(str)
+    assert(objectId.isInstanceOf[ObjectId])
+    assertEquals(objectId.toHexString, str)
+  }
+
+  test("documentToObjectId should extract ObjectId from Document") {
+    val objectId = new ObjectId()
+    val document = Document(DatabaseProvider.ObjectIdKey -> objectId)
+    val extractedObjectId = documentToObjectId(document)
+    assertEquals(extractedObjectId, objectId)
+  }
+}
\ No newline at end of file
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ConnectionSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ConnectionSuite.scala
new file mode 100644
index 00000000..817bb333
--- /dev/null
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ConnectionSuite.scala
@@ -0,0 +1,193 @@
+package dev.mongocamp.driver.mongodb.jdbc
+
+import dev.mongocamp.driver.mongodb.*
+import dev.mongocamp.driver.mongodb.jdbc.statement.MongoPreparedStatement
+
+import java.sql.{Connection, DriverManager, SQLFeatureNotSupportedException, SQLWarning, Savepoint}
+import java.util.Properties
+import java.util.concurrent.Executor
+
+class ConnectionSuite extends BaseJdbcSuite {
+
+  test("getDatabaseProvider should return the database provider") {
+    val driver = new MongoJdbcDriver()
+    val connectionUrl = "jdbc:mongodb://localhost:27017/mongocamp-unit-test?retryWrites=true&loadBalanced=false&serverSelectionTimeoutMS=5000&connectTimeoutMS=10000"
+    val propertiesInfo = driver.getPropertyInfo(connectionUrl, new Properties())
+    assertEquals(propertiesInfo.length, 5)
+  }
+
+  test("getDatabaseProvider should return the database provider") {
+    assertEquals(connection.asInstanceOf[MongoJdbcConnection].getDatabaseProvider.collections().results().isEmpty, false)
+  }
+
+  test("createStatement should return a MongoPreparedStatement") {
+    assert(connection.createStatement().isInstanceOf[MongoPreparedStatement])
+    assert(connection.createStatement(0, 0).isInstanceOf[MongoPreparedStatement])
+    assert(connection.createStatement(0, 0, 0).isInstanceOf[MongoPreparedStatement])
+  }
+
+  test("prepareStatement should return a MongoPreparedStatement") {
+    assert(connection.prepareStatement("SELECT * FROM people").isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareStatement("SELECT * FROM people", 0).isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareStatement("SELECT * FROM people", 0, 0).isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareStatement("SELECT * FROM people", 0, 0, 0).isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareStatement("SELECT * FROM people", Array[Int]()).isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareStatement("SELECT * FROM people", Array[String]()).isInstanceOf[MongoPreparedStatement])
+  }
+
+  test("prepareCall should return a MongoPreparedStatement") {
+    assert(connection.prepareCall("SELECT * FROM people").isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareCall("SELECT * FROM people", 0, 0).isInstanceOf[MongoPreparedStatement])
+    assert(connection.prepareCall("SELECT * FROM people", 0, 0, 0).isInstanceOf[MongoPreparedStatement])
+  }
+
+  test("nativeSQL should return the same SQL string") {
+    val sql = "SELECT * FROM people"
+    assertEquals(connection.nativeSQL(sql), sql)
+  }
+
+  test("setAutoCommit should not throw an exception") {
+    connection.setAutoCommit(true)
+  }
+
+  test("getAutoCommit should return true") {
+    assert(connection.getAutoCommit)
+  }
+
+  test("commit should not throw an exception") {
+    connection.commit()
+  }
+
+  test("rollback should not throw an exception") {
+    connection.rollback()
+  }
+
+  test("getMetaData should return MongoDatabaseMetaData") {
+    assert(connection.getMetaData.isInstanceOf[MongoDatabaseMetaData])
+  }
+
+  test("setReadOnly should set the connection to read-only") {
+    connection.setReadOnly(true)
+    assert(connection.isReadOnly)
+  }
+
+  test("setCatalog should not throw an exception") {
+    connection.setCatalog("testCatalog")
+  }
+
+  test("getCatalog should return null") {
+    assertEquals(connection.getCatalog, null)
+  }
+
+  test("intercept not implemented sql features") {
+    intercept[SQLFeatureNotSupportedException](connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED))
+    intercept[SQLFeatureNotSupportedException](connection.createNClob())
+    intercept[SQLFeatureNotSupportedException](connection.createBlob())
+    intercept[SQLFeatureNotSupportedException](connection.createClob())
+    intercept[SQLFeatureNotSupportedException](connection.createSQLXML())
+    intercept[SQLFeatureNotSupportedException](connection.createStruct("", null))
+    intercept[SQLFeatureNotSupportedException](connection.createArrayOf("typeName: String", null))
+  }
+
+  test("getTransactionIsolation should return TRANSACTION_NONE") {
+    assertEquals(connection.getTransactionIsolation, Connection.TRANSACTION_NONE)
+  }
+
+  test("getWarnings should return null") {
+    assertEquals(connection.getWarnings, null)
+  }
+
+  test("clearWarnings should not throw an exception") {
+    connection.clearWarnings()
+  }
+
+  test("getTypeMap should return null") {
+    assertEquals(connection.getTypeMap, null)
+  }
+
+  test("setTypeMap should not throw an exception") {
+    connection.setTypeMap(new java.util.HashMap[String, Class[_]]())
+  }
+
+  test("setHoldability should not throw an exception") {
+    connection.setHoldability(0)
+  }
+
+  test("getHoldability should return 0") {
+    assertEquals(connection.getHoldability, 0)
+  }
+
+  test("setSavepoint should return null") {
+    assertEquals(connection.setSavepoint(), null)
+  }
+
+  test("setSavepoint with name should return null") {
+    assertEquals(connection.setSavepoint("savepoint"), null)
+  }
+
+  test("rollback with savepoint should not throw an exception") {
+    connection.rollback(null.asInstanceOf[Savepoint])
+  }
+
+  test("releaseSavepoint should not throw an exception") {
+    connection.releaseSavepoint(null.asInstanceOf[Savepoint])
+  }
+
+  test("isValid should return true") {
+    assert(connection.isValid(0))
+  }
+
+  test("setClientInfo with name and value should not throw an exception") {
+    connection.setClientInfo("ApplicationName", "testApp")
+  }
+
+  test("setClientInfo with properties should not throw an exception") {
+    val properties = new Properties()
+    properties.setProperty("ApplicationName", "testApp")
+    connection.setClientInfo(properties)
+  }
+
+  test("getClientInfo with name should return the application name") {
+    connection.setClientInfo("ApplicationName", "testApp")
+    assertEquals(connection.getClientInfo("ApplicationName"), "testApp")
+  }
+
+  test("getClientInfo should return properties with application name") {
+    connection.setClientInfo("ApplicationName", "testApp")
+    val properties = connection.getClientInfo
+    assertEquals(properties.getProperty("ApplicationName"), "testApp")
+  }
+
+  test("getSchema should return the default database name") {
+    assertEquals(connection.getSchema, "mongocamp-unit-test")
+  }
+
+  test("setSchema should not throw an exception") {
+    connection.setSchema("testSchema")
+  }
+
+  test("abort should not throw an exception") {
+    connection.abort(null.asInstanceOf[Executor])
+  }
+
+  test("setNetworkTimeout should not throw an exception") {
+    connection.setNetworkTimeout(null.asInstanceOf[Executor], 0)
+  }
+
+  test("getNetworkTimeout should return 0") {
+    assertEquals(connection.getNetworkTimeout, 0)
+  }
+
+  test("unwrap should return null") {
+    assertEquals(connection.unwrap(classOf[Connection]), null)
+  }
+
+  test("isWrapperFor should return false") {
+    assert(!connection.isWrapperFor(classOf[Connection]))
+  }
+
+  test("close should close the connection") {
+    connection.close()
+    assertEquals(connection.isClosed, true)
+  }
+}
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ExploreJdbcSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ExploreJdbcSuite.scala
index e91be9d5..8c91bbd8 100644
--- a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ExploreJdbcSuite.scala
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/ExploreJdbcSuite.scala
@@ -1,6 +1,9 @@
 package dev.mongocamp.driver.mongodb.jdbc
 
-import java.sql.Types
+import dev.mongocamp.driver.mongodb.BuildInfo
+import dev.mongocamp.driver.mongodb.jdbc.resultSet.MongoDbResultSet
+
+import java.sql.{ Connection, DatabaseMetaData, ResultSet, Types }
 
 class ExploreJdbcSuite extends BaseJdbcSuite {
 
@@ -58,4 +61,699 @@ class ExploreJdbcSuite extends BaseJdbcSuite {
     assertEquals(columns, 20)
     assert(tablePersonFound)
   }
+
+  test("allProceduresAreCallable should return false") {
+    assertEquals(connection.getMetaData.allProceduresAreCallable(), false)
+  }
+
+  test("allTablesAreSelectable should return false") {
+    assertEquals(connection.getMetaData.allTablesAreSelectable(), false)
+  }
+
+  test("getURL should return connection string") {
+    assertEquals(connection.getMetaData.getURL, "mongodb://127.0.0.1:27017/mongocamp-unit-test")
+  }
+
+  test("getUserName should return user name") {
+    assertEquals(connection.getMetaData.getUserName, "not set")
+  }
+
+  test("isReadOnly should return false") {
+    assertEquals(connection.getMetaData.isReadOnly, false)
+  }
+
+  test("nullsAreSortedHigh should return false") {
+    assertEquals(connection.getMetaData.nullsAreSortedHigh(), false)
+  }
+
+  test("nullsAreSortedLow should return false") {
+    assertEquals(connection.getMetaData.nullsAreSortedLow(), false)
+  }
+
+  test("nullsAreSortedAtStart should return false") {
+    assertEquals(connection.getMetaData.nullsAreSortedAtStart(), false)
+  }
+
+  test("nullsAreSortedAtEnd should return false") {
+    assertEquals(connection.getMetaData.nullsAreSortedAtEnd(), false)
+  }
+
+  test("getDatabaseProductName should return mongodb") {
+    assertEquals(connection.getMetaData.getDatabaseProductName, "mongodb")
+  }
+
+  test("getDatabaseProductVersion should return version") {
+    assertNotEquals(connection.getMetaData.getDatabaseProductVersion, null)
+  }
+
+  test("getDriverName should return driver name") {
+    assertEquals(connection.getMetaData.getDriverName, BuildInfo.name)
+  }
+
+  test("getDriverVersion should return driver version") {
+    assertEquals(connection.getMetaData.getDriverVersion, BuildInfo.version)
+  }
+
+  test("getDriverMajorVersion should return major version") {
+    assertEquals(connection.getMetaData.getDriverMajorVersion, BuildInfo.version.split("\\.")(0).toInt)
+  }
+
+  test("getDriverMinorVersion should return minor version") {
+    assertEquals(connection.getMetaData.getDriverMinorVersion, BuildInfo.version.split("\\.")(1).toInt)
+  }
+
+  test("usesLocalFiles should return false") {
+    assertEquals(connection.getMetaData.usesLocalFiles(), false)
+  }
+
+  test("usesLocalFilePerTable should return false") {
+    assertEquals(connection.getMetaData.usesLocalFilePerTable(), false)
+  }
+
+  test("supportsMixedCaseIdentifiers should return false") {
+    assertEquals(connection.getMetaData.supportsMixedCaseIdentifiers(), false)
+  }
+
+  test("storesUpperCaseIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesUpperCaseIdentifiers(), false)
+  }
+
+  test("storesLowerCaseIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesLowerCaseIdentifiers(), false)
+  }
+
+  test("storesMixedCaseIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesMixedCaseIdentifiers(), false)
+  }
+
+  test("supportsMixedCaseQuotedIdentifiers should return false") {
+    assertEquals(connection.getMetaData.supportsMixedCaseQuotedIdentifiers(), false)
+  }
+
+  test("storesUpperCaseQuotedIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesUpperCaseQuotedIdentifiers(), false)
+  }
+
+  test("storesLowerCaseQuotedIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesLowerCaseQuotedIdentifiers(), false)
+  }
+
+  test("storesMixedCaseQuotedIdentifiers should return false") {
+    assertEquals(connection.getMetaData.storesMixedCaseQuotedIdentifiers(), false)
+  }
+
+  test("getIdentifierQuoteString should return null") {
+    assertEquals(connection.getMetaData.getIdentifierQuoteString, null)
+  }
+
+  test("getSQLKeywords should return empty string") {
+    assertEquals(connection.getMetaData.getSQLKeywords, "")
+  }
+
+  test("getNumericFunctions should return null") {
+    assertEquals(connection.getMetaData.getNumericFunctions, null)
+  }
+
+  test("getStringFunctions should return null") {
+    assertEquals(connection.getMetaData.getStringFunctions, null)
+  }
+
+  test("getSystemFunctions should return null") {
+    assertEquals(connection.getMetaData.getSystemFunctions, null)
+  }
+
+  test("getTimeDateFunctions should return date") {
+    assertEquals(connection.getMetaData.getTimeDateFunctions, "date")
+  }
+
+  test("getSearchStringEscape should return \\") {
+    assertEquals(connection.getMetaData.getSearchStringEscape, "\\")
+  }
+
+  test("getExtraNameCharacters should return null") {
+    assertEquals(connection.getMetaData.getExtraNameCharacters, null)
+  }
+
+  test("supportsAlterTableWithAddColumn should return false") {
+    assertEquals(connection.getMetaData.supportsAlterTableWithAddColumn(), false)
+  }
+
+  test("supportsAlterTableWithDropColumn should return false") {
+    assertEquals(connection.getMetaData.supportsAlterTableWithDropColumn(), false)
+  }
+
+  test("supportsColumnAliasing should return true") {
+    assertEquals(connection.getMetaData.supportsColumnAliasing(), true)
+  }
+
+  test("nullPlusNonNullIsNull should return false") {
+    assertEquals(connection.getMetaData.nullPlusNonNullIsNull(), false)
+  }
+
+  test("supportsConvert should return false") {
+    assertEquals(connection.getMetaData.supportsConvert(), false)
+  }
+
+  test("supportsConvert with parameters should return false") {
+    assertEquals(connection.getMetaData.supportsConvert(0, 0), false)
+  }
+
+  test("supportsTableCorrelationNames should return false") {
+    assertEquals(connection.getMetaData.supportsTableCorrelationNames(), false)
+  }
+
+  test("supportsDifferentTableCorrelationNames should return false") {
+    assertEquals(connection.getMetaData.supportsDifferentTableCorrelationNames(), false)
+  }
+
+  test("supportsExpressionsInOrderBy should return false") {
+    assertEquals(connection.getMetaData.supportsExpressionsInOrderBy(), false)
+  }
+
+  test("supportsOrderByUnrelated should return true") {
+    assertEquals(connection.getMetaData.supportsOrderByUnrelated(), true)
+  }
+
+  test("supportsGroupBy should return true") {
+    assertEquals(connection.getMetaData.supportsGroupBy(), true)
+  }
+
+  test("supportsGroupByUnrelated should return true") {
+    assertEquals(connection.getMetaData.supportsGroupByUnrelated(), true)
+  }
+
+  test("supportsGroupByBeyondSelect should return true") {
+    assertEquals(connection.getMetaData.supportsGroupByBeyondSelect(), true)
+  }
+
+  test("supportsLikeEscapeClause should return true") {
+    assertEquals(connection.getMetaData.supportsLikeEscapeClause(), true)
+  }
+
+  test("supportsMultipleResultSets should return true") {
+    assertEquals(connection.getMetaData.supportsMultipleResultSets(), true)
+  }
+
+  test("supportsMultipleTransactions should return false") {
+    assertEquals(connection.getMetaData.supportsMultipleTransactions(), false)
+  }
+
+  test("supportsNonNullableColumns should return true") {
+    assertEquals(connection.getMetaData.supportsNonNullableColumns(), true)
+  }
+
+  test("supportsMinimumSQLGrammar should return false") {
+    assertEquals(connection.getMetaData.supportsMinimumSQLGrammar(), false)
+  }
+
+  test("supportsCoreSQLGrammar should return false") {
+    assertEquals(connection.getMetaData.supportsCoreSQLGrammar(), false)
+  }
+
+  test("supportsExtendedSQLGrammar should return false") {
+    assertEquals(connection.getMetaData.supportsExtendedSQLGrammar(), false)
+  }
+
+  test("supportsANSI92EntryLevelSQL should return false") {
+    assertEquals(connection.getMetaData.supportsANSI92EntryLevelSQL(), false)
+  }
+
+  test("supportsANSI92IntermediateSQL should return false") {
+    assertEquals(connection.getMetaData.supportsANSI92IntermediateSQL(), false)
+  }
+
+  test("supportsANSI92FullSQL should return false") {
+    assertEquals(connection.getMetaData.supportsANSI92FullSQL(), false)
+  }
+
+  test("supportsIntegrityEnhancementFacility should return false") {
+    assertEquals(connection.getMetaData.supportsIntegrityEnhancementFacility(), false)
+  }
+
+  test("supportsOuterJoins should return false") {
+    assertEquals(connection.getMetaData.supportsOuterJoins(), false)
+  }
+
+  test("supportsFullOuterJoins should return false") {
+    assertEquals(connection.getMetaData.supportsFullOuterJoins(), false)
+  }
+
+  test("supportsLimitedOuterJoins should return false") {
+    assertEquals(connection.getMetaData.supportsLimitedOuterJoins(), false)
+  }
+
+  test("getSchemaTerm should return database") {
+    assertEquals(connection.getMetaData.getSchemaTerm, "database")
+  }
+
+  test("getProcedureTerm should return null") {
+    assertEquals(connection.getMetaData.getProcedureTerm, null)
+  }
+
+  test("getCatalogTerm should return database") {
+    assertEquals(connection.getMetaData.getCatalogTerm, "database")
+  }
+
+  test("isCatalogAtStart should return true") {
+    assertEquals(connection.getMetaData.isCatalogAtStart, true)
+  }
+
+  test("getCatalogSeparator should return .") {
+    assertEquals(connection.getMetaData.getCatalogSeparator, ".")
+  }
+
+  test("supportsSchemasInDataManipulation should return false") {
+    assertEquals(connection.getMetaData.supportsSchemasInDataManipulation(), false)
+  }
+
+  test("supportsSchemasInProcedureCalls should return false") {
+    assertEquals(connection.getMetaData.supportsSchemasInProcedureCalls(), false)
+  }
+
+  test("supportsSchemasInTableDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsSchemasInTableDefinitions(), false)
+  }
+
+  test("supportsSchemasInIndexDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsSchemasInIndexDefinitions(), false)
+  }
+
+  test("supportsSchemasInPrivilegeDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsSchemasInPrivilegeDefinitions(), false)
+  }
+
+  test("supportsCatalogsInDataManipulation should return true") {
+    assertEquals(connection.getMetaData.supportsCatalogsInDataManipulation(), true)
+  }
+
+  test("supportsCatalogsInProcedureCalls should return false") {
+    assertEquals(connection.getMetaData.supportsCatalogsInProcedureCalls(), false)
+  }
+
+  test("supportsCatalogsInTableDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsCatalogsInTableDefinitions(), false)
+  }
+
+  test("supportsCatalogsInIndexDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsCatalogsInIndexDefinitions(), false)
+  }
+
+  test("supportsCatalogsInPrivilegeDefinitions should return false") {
+    assertEquals(connection.getMetaData.supportsCatalogsInPrivilegeDefinitions(), false)
+  }
+
+  test("supportsPositionedDelete should return false") {
+    assertEquals(connection.getMetaData.supportsPositionedDelete(), false)
+  }
+
+  test("supportsPositionedUpdate should return false") {
+    assertEquals(connection.getMetaData.supportsPositionedUpdate(), false)
+  }
+
+  test("supportsSelectForUpdate should return false") {
+    assertEquals(connection.getMetaData.supportsSelectForUpdate(), false)
+  }
+
+  test("supportsStoredProcedures should return false") {
+    assertEquals(connection.getMetaData.supportsStoredProcedures(), false)
+  }
+
+  test("supportsSubqueriesInComparisons should return false") {
+    assertEquals(connection.getMetaData.supportsSubqueriesInComparisons(), false)
+  }
+
+  test("supportsSubqueriesInExists should return false") {
+    assertEquals(connection.getMetaData.supportsSubqueriesInExists(), false)
+  }
+
+  test("supportsSubqueriesInIns should return false") {
+    assertEquals(connection.getMetaData.supportsSubqueriesInIns(), false)
+  }
+
+  test("supportsSubqueriesInQuantifieds should return false") {
+    assertEquals(connection.getMetaData.supportsSubqueriesInQuantifieds(), false)
+  }
+
+  test("supportsCorrelatedSubqueries should return false") {
+    assertEquals(connection.getMetaData.supportsCorrelatedSubqueries(), false)
+  }
+
+  test("supportsUnion should return true") {
+    assertEquals(connection.getMetaData.supportsUnion(), true)
+  }
+
+  test("supportsUnionAll should return true") {
+    assertEquals(connection.getMetaData.supportsUnionAll(), true)
+  }
+
+  test("supportsOpenCursorsAcrossCommit should return false") {
+    assertEquals(connection.getMetaData.supportsOpenCursorsAcrossCommit(), false)
+  }
+
+  test("supportsOpenCursorsAcrossRollback should return false") {
+    assertEquals(connection.getMetaData.supportsOpenCursorsAcrossRollback(), false)
+  }
+
+  test("supportsOpenStatementsAcrossCommit should return false") {
+    assertEquals(connection.getMetaData.supportsOpenStatementsAcrossCommit(), false)
+  }
+
+  test("supportsOpenStatementsAcrossRollback should return false") {
+    assertEquals(connection.getMetaData.supportsOpenStatementsAcrossRollback(), false)
+  }
+
+  test("getMaxBinaryLiteralLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxBinaryLiteralLength, 0)
+  }
+
+  test("getMaxCharLiteralLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxCharLiteralLength, 0)
+  }
+
+  test("getMaxColumnNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnNameLength, 0)
+  }
+
+  test("getMaxColumnsInGroupBy should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnsInGroupBy, 0)
+  }
+
+  test("getMaxColumnsInIndex should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnsInIndex, 0)
+  }
+
+  test("getMaxColumnsInOrderBy should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnsInOrderBy, 0)
+  }
+
+  test("getMaxColumnsInSelect should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnsInSelect, 0)
+  }
+
+  test("getMaxColumnsInTable should return 0") {
+    assertEquals(connection.getMetaData.getMaxColumnsInTable, 0)
+  }
+
+  test("getMaxConnections should return 0") {
+    assertEquals(connection.getMetaData.getMaxConnections, 0)
+  }
+
+  test("getMaxCursorNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxCursorNameLength, 0)
+  }
+
+  test("getMaxIndexLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxIndexLength, 0)
+  }
+
+  test("getMaxSchemaNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxSchemaNameLength, 0)
+  }
+
+  test("getMaxProcedureNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxProcedureNameLength, 0)
+  }
+
+  test("getMaxCatalogNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxCatalogNameLength, 0)
+  }
+
+  test("getMaxRowSize should return 0") {
+    assertEquals(connection.getMetaData.getMaxRowSize, 0)
+  }
+
+  test("doesMaxRowSizeIncludeBlobs should return false") {
+    assertEquals(connection.getMetaData.doesMaxRowSizeIncludeBlobs(), false)
+  }
+
+  test("getMaxStatementLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxStatementLength, 0)
+  }
+
+  test("getMaxStatements should return 0") {
+    assertEquals(connection.getMetaData.getMaxStatements, 0)
+  }
+
+  test("getMaxTableNameLength should return 90") {
+    assertEquals(connection.getMetaData.getMaxTableNameLength, 90)
+  }
+
+  test("getMaxTablesInSelect should return 0") {
+    assertEquals(connection.getMetaData.getMaxTablesInSelect, 0)
+  }
+
+  test("getMaxUserNameLength should return 0") {
+    assertEquals(connection.getMetaData.getMaxUserNameLength, 0)
+  }
+
+  test("getDefaultTransactionIsolation should return TRANSACTION_NONE") {
+    assertEquals(connection.getMetaData.getDefaultTransactionIsolation, Connection.TRANSACTION_NONE)
+  }
+
+  test("supportsTransactions should return false") {
+    assertEquals(connection.getMetaData.supportsTransactions(), false)
+  }
+
+  test("supportsTransactionIsolationLevel should return false") {
+    assertEquals(connection.getMetaData.supportsTransactionIsolationLevel(0), false)
+  }
+
+  test("supportsDataDefinitionAndDataManipulationTransactions should return false") {
+    assertEquals(connection.getMetaData.supportsDataDefinitionAndDataManipulationTransactions(), false)
+  }
+
+  test("supportsDataManipulationTransactionsOnly should return false") {
+    assertEquals(connection.getMetaData.supportsDataManipulationTransactionsOnly(), false)
+  }
+
+  test("dataDefinitionCausesTransactionCommit should return false") {
+    assertEquals(connection.getMetaData.dataDefinitionCausesTransactionCommit(), false)
+  }
+
+  test("dataDefinitionIgnoredInTransactions should return false") {
+    assertEquals(connection.getMetaData.dataDefinitionIgnoredInTransactions(), false)
+  }
+
+  test("getProcedures should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getProcedures("", "", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getProcedureColumns should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getProcedureColumns("", "", "", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getTables should return ResultSet with tables") {
+    val resultSet = connection.getMetaData.getTables("", "", "", Array("TABLE"))
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), true)
+    assertEquals(resultSet.getString("TABLE_NAME"), "system.version")
+  }
+
+  test("getSchemas should return ResultSet with schemas") {
+    val resultSet = connection.getMetaData.getSchemas
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), true)
+    assertEquals(resultSet.getString("TABLE_SCHEM"), "admin")
+  }
+
+  test("getCatalogs should return ResultSet with catalogs") {
+    val resultSet = connection.getMetaData.getCatalogs
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), true)
+    assertEquals(resultSet.getString("TABLE_CAT"), "mongodb")
+  }
+
+  test("getTableTypes should return ResultSet with table types") {
+    val resultSet = connection.getMetaData.getTableTypes
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), true)
+    assertEquals(resultSet.getString("TABLE_TYPE"), "COLLECTION")
+  }
+
+  test("getColumns should return ResultSet with columns") {
+    val resultSet = connection.getMetaData.getColumns("", "db1", "coll1", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getColumnPrivileges should return null") {
+    assertEquals(connection.getMetaData.getColumnPrivileges("", "", "", ""), null)
+  }
+
+  test("getTablePrivileges should return null") {
+    assertEquals(connection.getMetaData.getTablePrivileges("", "", ""), null)
+  }
+
+  test("getBestRowIdentifier should return null") {
+    assertEquals(connection.getMetaData.getBestRowIdentifier("", "", "", 0, false), null)
+  }
+
+  test("getVersionColumns should return null") {
+    assertEquals(connection.getMetaData.getVersionColumns("", "", ""), null)
+  }
+
+  test("getPrimaryKeys should return ResultSet with primary keys") {
+    val resultSet = connection.getMetaData.getPrimaryKeys("", "testSchema", "testTable")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    // Add more assertions based on the expected content of the ResultSet
+  }
+
+  test("getImportedKeys should return null") {
+    assertEquals(connection.getMetaData.getImportedKeys("", "", ""), null)
+  }
+
+  test("getExportedKeys should return null") {
+    assertEquals(connection.getMetaData.getExportedKeys("", "", ""), null)
+  }
+
+  test("getCrossReference should return null") {
+    assertEquals(connection.getMetaData.getCrossReference("", "", "", "", "", ""), null)
+  }
+
+  test("getTypeInfo should return ResultSet with type info") {
+    val resultSet = connection.getMetaData.getTypeInfo
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    // Add more assertions based on the expected content of the ResultSet
+  }
+
+  test("getIndexInfo should return ResultSet with index info") {
+    val resultSet = connection.getMetaData.getIndexInfo("", "testSchema", "testTable", false, false)
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+  }
+
+  test("supportsResultSetType should return true for TYPE_FORWARD_ONLY") {
+    assertEquals(connection.getMetaData.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY), true)
+  }
+
+  test("supportsResultSetConcurrency should return false") {
+    assertEquals(connection.getMetaData.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY), false)
+  }
+
+  test("ownUpdatesAreVisible should return false") {
+    assertEquals(connection.getMetaData.ownUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("ownDeletesAreVisible should return false") {
+    assertEquals(connection.getMetaData.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("ownInsertsAreVisible should return false") {
+    assertEquals(connection.getMetaData.ownInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("othersUpdatesAreVisible should return false") {
+    assertEquals(connection.getMetaData.othersUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("othersDeletesAreVisible should return false") {
+    assertEquals(connection.getMetaData.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("othersInsertsAreVisible should return false") {
+    assertEquals(connection.getMetaData.othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("updatesAreDetected should return false") {
+    assertEquals(connection.getMetaData.updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("deletesAreDetected should return false") {
+    assertEquals(connection.getMetaData.deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("insertsAreDetected should return false") {
+    assertEquals(connection.getMetaData.insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY), false)
+  }
+
+  test("supportsBatchUpdates should return false") {
+    assertEquals(connection.getMetaData.supportsBatchUpdates(), false)
+  }
+
+  test("getUDTs should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getUDTs("", "", "", Array())
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getConnection should return the connection") {
+    assertEquals(connection.getMetaData.getConnection, connection)
+  }
+
+  test("supportsSavepoints should return false") {
+    assertEquals(connection.getMetaData.supportsSavepoints(), false)
+  }
+
+  test("supportsNamedParameters should return false") {
+    assertEquals(connection.getMetaData.supportsNamedParameters(), false)
+  }
+
+  test("supportsMultipleOpenResults should return false") {
+    assertEquals(connection.getMetaData.supportsMultipleOpenResults(), false)
+  }
+
+  test("supportsGetGeneratedKeys should return false") {
+    assertEquals(connection.getMetaData.supportsGetGeneratedKeys(), false)
+  }
+
+  test("getSuperTypes should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getSuperTypes("", "", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getSuperTables should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getSuperTables("", "", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("getAttributes should return empty ResultSet") {
+    val resultSet = connection.getMetaData.getAttributes("", "", "", "")
+    assert(resultSet.isInstanceOf[MongoDbResultSet])
+    assertEquals(resultSet.next(), false)
+  }
+
+  test("supportsResultSetHoldability should return false") {
+    assertEquals(connection.getMetaData.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT), false)
+  }
+
+  test("getResultSetHoldability should return HOLD_CURSORS_OVER_COMMIT") {
+    assertEquals(connection.getMetaData.getResultSetHoldability, ResultSet.HOLD_CURSORS_OVER_COMMIT)
+  }
+
+  test("getDatabaseMajorVersion should return the major version") {
+    assertEquals(connection.getMetaData.getDatabaseMajorVersion, 3) // Replace with the actual major version
+  }
+
+  test("getDatabaseMinorVersion should return the minor version") {
+    assertEquals(connection.getMetaData.getDatabaseMinorVersion, 0) // Replace with the actual minor version
+  }
+
+  test("getJDBCMajorVersion should return the JDBC major version") {
+    assertEquals(connection.getMetaData.getJDBCMajorVersion, 4)
+  }
+
+  test("getJDBCMinorVersion should return the JDBC minor version") {
+    assertEquals(connection.getMetaData.getJDBCMinorVersion, 2)
+  }
+
+  test("getSQLStateType should return sqlStateXOpen") {
+    assertEquals(connection.getMetaData.getSQLStateType, DatabaseMetaData.sqlStateXOpen)
+  }
+
+  test("locatorsUpdateCopy should return false") {
+    assertEquals(connection.getMetaData.locatorsUpdateCopy(), false)
+  }
+
+  test("supportsStatementPooling should return false") {
+    assertEquals(connection.getMetaData.supportsStatementPooling(), false)
+  }
+
+  test("getRowIdLifetime should return null") {
+    assertEquals(connection.getMetaData.getRowIdLifetime, null)
+  }
 }
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala
new file mode 100644
index 00000000..37c948ab
--- /dev/null
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala
@@ -0,0 +1,231 @@
+package dev.mongocamp.driver.mongodb.jdbc
+
+import dev.mongocamp.driver.mongodb.jdbc.resultSet.MongoDbResultSet
+import munit.FunSuite
+import org.joda.time.DateTime
+import org.mongodb.scala.bson.collection.immutable.Document
+import dev.mongocamp.driver.mongodb.*
+import org.mongodb.scala.model.Updates
+
+import java.sql.{Date, ResultSet, SQLFeatureNotSupportedException, Time, Timestamp}
+
+class MongoDbResultSetSuite extends BaseJdbcSuite {
+
+  def initializeResultSet(): ResultSet = {
+    super.beforeAll()
+    val data = List(
+      Document("id" -> 1, "name" -> "test_name", "active"    -> true, "date" -> new DateTime("2021-01-01T00:00:00Z").toDate),
+      Document("id" -> 2, "name" -> "another_name", "active" -> false)
+    )
+    val resultSet = new MongoDbResultSet(null, data, 0)
+    resultSet
+  }
+
+  test("next() should move to the next row") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.next())
+    assertEquals(resultSet.getInt("id"), 1)
+    assert(resultSet.next())
+    assertEquals(resultSet.getInt("id"), 2)
+    assert(!resultSet.next())
+  }
+
+  test("wasNull() should return false") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.wasNull())
+  }
+
+  test("getString() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getString("name"), "test_name")
+  }
+
+  test("getBoolean() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assert(resultSet.getBoolean("active"))
+  }
+
+  test("getInt() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getInt("id"), 1)
+  }
+
+  test("getDouble() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getDouble("id"), 1.0)
+  }
+
+  test("getDate() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getDate("date").toString, "2021-01-01")
+  }
+
+  test("getTime() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getTime("date").toString, new DateTime("2021-01-01T00:00:00Z").toString("HH:mm:ss"))
+  }
+
+  test("getTimestamp() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getTimestamp("date").toInstant.toString, "2021-01-01T00:00:00Z")
+  }
+
+  test("isBeforeFirst() should return true initially") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.isBeforeFirst)
+  }
+
+  test("isAfterLast() should return false initially") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.isAfterLast)
+  }
+
+  test("isFirst() should return true after first next()") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assert(resultSet.isFirst)
+  }
+
+  test("isLast() should return true after last next()") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    resultSet.next()
+    assert(resultSet.isLast)
+  }
+
+  test("getRow() should return the correct row number") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getRow, 1)
+  }
+
+  test("absolute() should return false") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.absolute(1))
+  }
+
+  test("relative() should return false") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.relative(1))
+  }
+
+  test("previous() should return false") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.previous())
+  }
+
+  test("getFetchDirection() should return FETCH_FORWARD") {
+    val resultSet = initializeResultSet()
+    assertEquals(resultSet.getFetchDirection, ResultSet.FETCH_FORWARD)
+  }
+
+  test("getFetchSize() should return 1") {
+    val resultSet = initializeResultSet()
+    assertEquals(resultSet.getFetchSize, 1)
+  }
+
+  test("getType() should return TYPE_FORWARD_ONLY") {
+    val resultSet = initializeResultSet()
+    assertEquals(resultSet.getType, ResultSet.TYPE_FORWARD_ONLY)
+  }
+
+  test("getObject() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getObject("id"), 1.asInstanceOf[AnyRef])
+  }
+
+  test("updateString() should update the value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    resultSet.updateString("name", "updated_name")
+    assertEquals(resultSet.getString("name"), "updated_name")
+  }
+
+  test("insertRow() should insert a new row") {
+    intercept[SQLFeatureNotSupportedException] {
+      val resultSet = initializeResultSet()
+      resultSet.moveToInsertRow()
+      resultSet.updateInt("id", 3)
+      resultSet.updateString("name", "new_name")
+      resultSet.updateBoolean("active", true)
+      resultSet.insertRow()
+    }
+  }
+
+  test("updateRow() should update the current row") {
+    val resultSet = connection.createStatement().executeQuery("select _id, id, name, age from people where age < 30 order by id asc")
+    resultSet.next()
+    resultSet.updateString("name", "updated_name")
+    resultSet.updateRow()
+    assertEquals(resultSet.getString("name"), "updated_name")
+    resultSet.refreshRow()
+    val document = connection.asInstanceOf[MongoJdbcConnection].getDatabaseProvider.dao("people").find("id", resultSet.getLong("id")).result()
+    assertEquals(document, resultSet.asInstanceOf[MongoDbResultSet].getDocument)
+  }
+
+  test("deleteRow() should delete the current row") {
+    val resultSet = connection.createStatement().executeQuery("select _id, id, name, age from people where id = 10")
+    resultSet.next()
+    resultSet.deleteRow()
+    assert(!resultSet.next())
+    val document = connection.asInstanceOf[MongoJdbcConnection].getDatabaseProvider.dao("people").find("id", 10).resultOption()
+    assert(document.isEmpty)
+  }
+
+  test("refreshRow() should refresh the current row") {
+    val resultSet = connection.createStatement().executeQuery("select _id, id, name, age from people where id = 42")
+    resultSet.next()
+    assertEquals(resultSet.getString("name"), "Aisha Buckner")
+    connection.asInstanceOf[MongoJdbcConnection].getDatabaseProvider.dao("people").updateOne(Map("id" -> 42), Updates.set("name", "updated_name")).result()
+    resultSet.refreshRow()
+    assertEquals(resultSet.getString("name"), "updated_name")
+  }
+
+  test("getMetaData() should return the correct metadata") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.getMetaData != null)
+  }
+
+  test("findColumn() should return the correct column index") {
+    val resultSet = initializeResultSet()
+    assertEquals(resultSet.findColumn("id"), 0)
+  }
+
+  test("getWarnings() should return null") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.getWarnings == null)
+  }
+
+  test("clearWarnings() should not throw an exception") {
+    val resultSet = initializeResultSet()
+    resultSet.clearWarnings()
+  }
+
+  test("getCursorName() should return null") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.getCursorName == null)
+  }
+
+  test("getStatement() should return null") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.getStatement == null)
+  }
+
+  test("unwrap() should return null") {
+    val resultSet = initializeResultSet()
+    assert(resultSet.unwrap(classOf[MongoDbResultSet]) == null)
+  }
+
+  test("isWrapperFor() should return false") {
+    val resultSet = initializeResultSet()
+    assert(!resultSet.isWrapperFor(classOf[MongoDbResultSet]))
+  }
+}
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSpec.scala b/src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSuite.scala
similarity index 98%
rename from src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSpec.scala
rename to src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSuite.scala
index fc3a3bcd..172ef869 100644
--- a/src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSpec.scala
+++ b/src/test/scala/dev/mongocamp/driver/mongodb/sql/UpdateSqlSuite.scala
@@ -7,7 +7,7 @@ import dev.mongocamp.driver.mongodb.test.UniversityDatabase.GradeDAO
 import munit.FunSuite
 import org.bson.types.ObjectId
 
-class UpdateSqlSpec extends FunSuite {
+class UpdateSqlSuite extends FunSuite {
 
   override def beforeEach(context: BeforeEach): Unit = {
     GradeDAO.drop().result()