test: added more tests for jdbc package

QuadStingray · QuadStingray · commit 8d28c81c3651 · 2025-02-06T22:56:26.000+01:00
diff --git a/README.md b/README.md
@@ -152,7 +152,8 @@ class RestaurantDemoSpec extends Specification with RestaurantDemoDatabaseFuncti
 ## Run Tests
 ```shell
 docker rm -f mongodb;
-docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest; 
+docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest;
+sbt test 
 ```
 
 ## Supporters
diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSet.scala
@@ -251,7 +251,7 @@ class MongoDbResultSet(collectionDao: MongoDAO[Document], data: List[Document],
 
   override def getMetaData: ResultSetMetaData = {
     checkClosed()
-    new MongoDbResultSetMetaData(collectionDao, data)
+    new MongoDbResultSetMetaData(collectionDao, data, keySet)
   }
 
   override def getObject(columnIndex: Int): AnyRef = {
diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/resultSet/MongoDbResultSetMetaData.scala
@@ -54,6 +54,17 @@ class MongoDbResultSetMetaData extends ResultSetMetaData {
 
   override def getColumnCount: Int = document.size
 
+  override def getColumnLabel(column: Int): String = {
+    val keys: Iterable[String] = if (keySet.nonEmpty) {
+      keySet
+    } else {
+      document.keys
+    }
+    keys.toList(column - 1)
+  }
+
+  override def getColumnName(column: Int): String = getColumnLabel(column)
+
   override def isAutoIncrement(column: Int): Boolean = false
 
   override def isCaseSensitive(column: Int): Boolean = true
@@ -68,17 +79,6 @@ class MongoDbResultSetMetaData extends ResultSetMetaData {
 
   override def getColumnDisplaySize(column: Int): Int = Int.MaxValue
 
-  override def getColumnLabel(column: Int): String = {
-    val keys : Iterable[String] =if (keySet.nonEmpty) {
-      keySet
-    } else {
-      document.keys
-    }
-    keys.toList(column - 1)
-  }
-
-  override def getColumnName(column: Int): String = getColumnLabel(column)
-
   override def getSchemaName(column: Int): String = collectionDao.databaseName
 
   override def getPrecision(column: Int): Int = 0
@@ -90,7 +90,7 @@ class MongoDbResultSetMetaData extends ResultSetMetaData {
   override def getCatalogName(column: Int): String = collectionDao.name
 
   override def getColumnType(column: Int): Int = {
-    document.values.toList(column - 1) match {
+    document(getColumnLabel(column)) match {
       case _: BsonInt32   => java.sql.Types.INTEGER
       case _: BsonInt64   => java.sql.Types.BIGINT
       case _: BsonNumber  => java.sql.Types.DOUBLE
@@ -136,6 +136,11 @@ class MongoDbResultSetMetaData extends ResultSetMetaData {
   override def isWrapperFor(iface: Class[_]): Boolean = false
 
   def getColumnIndex(columnLabel: String): Int = {
-    document.keys.toList.indexOf(columnLabel)
+    val keys: List[String] = if (keySet.nonEmpty) {
+      keySet
+    } else {
+      document.keys.toList
+    }
+    keys.indexOf(columnLabel) + 1
   }
 }
diff --git a/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala b/src/main/scala/dev/mongocamp/driver/mongodb/jdbc/statement/MongoPreparedStatement.scala
@@ -7,7 +7,6 @@ import dev.mongocamp.driver.mongodb.jdbc.{MongoJdbcCloseable, MongoJdbcConnectio
 import dev.mongocamp.driver.mongodb.json.JsonConverter
 import dev.mongocamp.driver.mongodb.sql.MongoSqlQueryHolder
 import dev.mongocamp.driver.mongodb.{Converter, GenericObservable}
-import jdk.graal.compiler.util.json.JsonParser
 import org.joda.time.DateTime
 
 import java.io.{InputStream, Reader}
@@ -224,9 +223,9 @@ case class MongoPreparedStatement(connection: MongoJdbcConnection) extends Calla
       case t: Time =>
         parameters.put(parameterIndex, s"'${t.toInstant.toString}'")
       case a: Array[Byte] =>
-        parameters.put(parameterIndex, a.mkString("[", ",", "]"))
+        parameters.put(parameterIndex, new JsonConverter().toJson(a))
       case a: Iterable[_] =>
-        parameters.put(parameterIndex, a.mkString("[", ",", "]"))
+        parameters.put(parameterIndex, new JsonConverter().toJson(a))
       case _ =>
         parameters.put(parameterIndex, x.toString)
     }
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetMetaDataSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetMetaDataSuite.scala
@@ -0,0 +1,130 @@
+package dev.mongocamp.driver.mongodb.jdbc
+
+import dev.mongocamp.driver.mongodb.MongoDAO
+import dev.mongocamp.driver.mongodb.jdbc.resultSet.MongoDbResultSetMetaData
+import dev.mongocamp.driver.mongodb.jdbc.statement.MongoPreparedStatement
+import munit.FunSuite
+import org.mongodb.scala.Document
+
+import java.sql.ResultSetMetaData
+
+class MongoDbResultSetMetaDataSuite extends BaseJdbcSuite {
+
+  var metaData: ResultSetMetaData = _
+
+  override def beforeAll(): Unit = {
+    super.beforeAll()
+    val preparedStatement2 = MongoPreparedStatement(connection.asInstanceOf[MongoJdbcConnection])
+    preparedStatement2.executeUpdate("drop table testCollection")
+    preparedStatement2.executeUpdate("insert into testCollection (intField, stringField, booleanField) values (1, 'test', true)")
+    preparedStatement2.executeUpdate("insert into testCollection (intField, stringField, booleanField) values (2, 'test2', false)")
+    metaData = preparedStatement2.executeQuery("select intField, booleanField, stringField from testCollection").getMetaData
+  }
+
+  test("getColumnCount should return the correct column count") {
+    assertEquals(metaData.getColumnCount, 3)
+  }
+
+  test("getColumnLabel should return the correct column label") {
+    assertEquals(metaData.getColumnLabel(1), "intField")
+    assertEquals(metaData.getColumnLabel(2), "booleanField")
+    assertEquals(metaData.getColumnLabel(3), "stringField")
+  }
+
+  test("getColumnName should return the correct column name") {
+    assertEquals(metaData.getColumnName(1), "intField")
+  }
+
+  test("isAutoIncrement should return false") {
+    assert(!metaData.isAutoIncrement(1))
+  }
+
+  test("isCaseSensitive should return true") {
+    assert(metaData.isCaseSensitive(1))
+  }
+
+  test("isSearchable should return true") {
+    assert(metaData.isSearchable(1))
+  }
+
+  test("isCurrency should return false") {
+    assert(!metaData.isCurrency(1))
+  }
+
+  test("isNullable should return columnNullable") {
+    assertEquals(metaData.isNullable(1), java.sql.ResultSetMetaData.columnNullable)
+  }
+
+  test("isSigned should return false") {
+    assert(!metaData.isSigned(1))
+  }
+
+  test("getColumnDisplaySize should return Int.MaxValue") {
+    assertEquals(metaData.getColumnDisplaySize(1), Int.MaxValue)
+  }
+
+  test("getSchemaName should return the database name") {
+    assertEquals(metaData.getSchemaName(1), "mongocamp-unit-test")
+  }
+
+  test("getPrecision should return 0") {
+    assertEquals(metaData.getPrecision(1), 0)
+  }
+
+  test("getScale should return 0") {
+    assertEquals(metaData.getScale(1), 0)
+  }
+
+  test("getTableName should return the collection name") {
+    assertEquals(metaData.getTableName(1), "testCollection")
+  }
+
+  test("getCatalogName should return the collection name") {
+    assertEquals(metaData.getCatalogName(1), "testCollection")
+  }
+
+  test("getColumnType should return the correct SQL type") {
+    assertEquals(metaData.getColumnType(1), java.sql.Types.BIGINT)
+    assertEquals(metaData.getColumnType(2), java.sql.Types.BOOLEAN)
+    assertEquals(metaData.getColumnType(3), java.sql.Types.VARCHAR)
+  }
+
+  test("getColumnTypeName should return the correct SQL type name") {
+    assertEquals(metaData.getColumnTypeName(1), "BIGINT")
+    assertEquals(metaData.getColumnTypeName(2), "BOOLEAN")
+    assertEquals(metaData.getColumnTypeName(3), "VARCHAR")
+  }
+
+  test("isReadOnly should return false") {
+    assert(!metaData.isReadOnly(1))
+  }
+
+  test("isWritable should return true") {
+    assert(metaData.isWritable(1))
+  }
+
+  test("isDefinitelyWritable should return true") {
+    assert(metaData.isDefinitelyWritable(1))
+  }
+
+  test("getColumnClassName should return the correct class name") {
+    assertEquals(metaData.getColumnClassName(1), classOf[java.lang.Long].getName)
+    assertEquals(metaData.getColumnClassName(2), classOf[java.lang.Boolean].getName)
+    assertEquals(metaData.getColumnClassName(3), classOf[java.lang.String].getName)
+  }
+
+  test("unwrap should return null") {
+    assertEquals(metaData.unwrap(classOf[Object]), null)
+  }
+
+  test("isWrapperFor should return false") {
+    assert(!metaData.isWrapperFor(classOf[Object]))
+  }
+
+  test("getColumnIndex should return the correct index") {
+    val metaData2 = metaData.asInstanceOf[MongoDbResultSetMetaData]
+    assertEquals(metaData2.getColumnIndex("intField"), 1)
+    assertEquals(metaData2.getColumnIndex("booleanField"), 2)
+    assertEquals(metaData2.getColumnIndex("stringField"), 3)
+  }
+}
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoDbResultSetSuite.scala
@@ -6,12 +6,11 @@ import org.joda.time.DateTime
 import org.mongodb.scala.bson.collection.immutable.Document
 import org.mongodb.scala.model.Updates
 
-import java.sql.{Date, ResultSet, SQLFeatureNotSupportedException, Time, Timestamp}
+import java.sql.*
 
 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)
@@ -52,12 +51,43 @@ class MongoDbResultSetSuite extends BaseJdbcSuite {
     assertEquals(resultSet.getInt("id"), 1)
   }
 
+  test("getByte() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getByte("id"), 1.toByte)
+  }
+
+  test("getBytes() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getByte("id"), 1.toByte)
+  }
+
+  test("getShort() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getShort("id"), 1.toShort)
+  }
+
+  test("getFloat() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getFloat("id"), 1.toFloat)
+  }
+
   test("getDouble() should return the correct value") {
     val resultSet = initializeResultSet()
     resultSet.next()
     assertEquals(resultSet.getDouble("id"), 1.0)
   }
 
+  test("getBigDecimal() should return the correct value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    assertEquals(resultSet.getBigDecimal("id"), new java.math.BigDecimal(1))
+    assertEquals(resultSet.getBigDecimal("id", 1), new java.math.BigDecimal(1).setScale(1))
+  }
+
   test("getDate() should return the correct value") {
     val resultSet = initializeResultSet()
     resultSet.next()
@@ -195,7 +225,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite {
 
   test("findColumn() should return the correct column index") {
     val resultSet = initializeResultSet()
-    assertEquals(resultSet.findColumn("id"), 0)
+    assertEquals(resultSet.findColumn("id"), 1)
   }
 
   test("getWarnings() should return null") {
@@ -227,7 +257,7 @@ class MongoDbResultSetSuite extends BaseJdbcSuite {
     val resultSet = initializeResultSet()
     assert(!resultSet.isWrapperFor(classOf[MongoDbResultSet]))
   }
-  
+
   test("updateNull should update the value to null") {
     val resultSet = initializeResultSet()
     resultSet.next()
@@ -246,38 +276,52 @@ class MongoDbResultSetSuite extends BaseJdbcSuite {
     val resultSet = initializeResultSet()
     resultSet.next()
     resultSet.updateInt(1, 42)
-    assert(resultSet.getInt(1) == 42)
+    assertEquals(resultSet.getInt(1), 42)
+  }
+
+  test("updateFloat should update the value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    resultSet.updateFloat(1, 42.toFloat)
+    assertEquals(resultSet.getFloat(1), 42.toFloat)
+  }
+
+  test("updateBigDecimal should update the value") {
+    val resultSet = initializeResultSet()
+    resultSet.next()
+    resultSet.updateBigDecimal(1, new java.math.BigDecimal(42))
+    assertEquals(resultSet.getBigDecimal(1), new java.math.BigDecimal(42))
   }
 
   test("updateString should update the value") {
     val resultSet = initializeResultSet()
     resultSet.next()
     resultSet.updateString(2, "updated_name")
-    assert(resultSet.getString(2) == "updated_name")
+    assertEquals(resultSet.getString(2), "updated_name")
   }
 
   test("updateDate should update the value") {
     val resultSet = initializeResultSet()
     resultSet.next()
     val newDate = new Date(1622505600000L)
     resultSet.updateDate(4, newDate)
-    assert(resultSet.getDate(4) == newDate)
+    assertEquals(resultSet.getDate(4), newDate)
   }
 
   test("updateTime should update the value") {
     val resultSet = initializeResultSet()
     resultSet.next()
     val newTime = new Time(1622505600000L)
     resultSet.updateTime(4, newTime)
-    assert(resultSet.getTime(4) == newTime)
+    assertEquals(resultSet.getTime(4), newTime)
   }
 
   test("updateTimestamp should update the value") {
     val resultSet = initializeResultSet()
     resultSet.next()
     val newTimestamp = new Timestamp(1622505600000L)
     resultSet.updateTimestamp(4, newTimestamp)
-    assert(resultSet.getTimestamp(4) == newTimestamp)
+    assertEquals(resultSet.getTimestamp(4), newTimestamp)
   }
 
   test("updateObject should update the value") {
@@ -304,8 +348,24 @@ class MongoDbResultSetSuite extends BaseJdbcSuite {
 
   test("getConcurrency should throw SQLFeatureNotSupportedException") {
     val resultSet = initializeResultSet()
-    intercept[SQLFeatureNotSupportedException] {
-      resultSet.getConcurrency
-    }
+    intercept[SQLFeatureNotSupportedException] (resultSet.getConcurrency)
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateAsciiStream(99, null, 1))
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateAsciiStream("updateAsciiStream", null, 1))
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateBinaryStream(99, null, 1))
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateBinaryStream("updateBinaryStream", null, 1))
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateCharacterStream(99, null, 1))
+    intercept[SQLFeatureNotSupportedException] (resultSet.updateCharacterStream("updateCharacterStream", null, 1))
+
   }
+
+  test("null values for not implemented get methods") {
+    val resultSet = initializeResultSet()
+    assertEquals(resultSet.getAsciiStream(1), null)
+    assertEquals(resultSet.getUnicodeStream(1), null)
+    assertEquals(resultSet.getBinaryStream(1), null)
+    assertEquals(resultSet.getAsciiStream("id"), null)
+    assertEquals(resultSet.getUnicodeStream("id"), null)
+    assertEquals(resultSet.getBinaryStream("id"), null)
+  }
+
 }
diff --git a/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala b/src/test/scala/dev/mongocamp/driver/mongodb/jdbc/MongoPreparedStatementSuite.scala

Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ class MongoDbResultSet(collectionDao: MongoDAO[Document], data: List[Document],`
`251`	`251`
`252`	`252`	`override def getMetaData: ResultSetMetaData = {`
`253`	`253`	`checkClosed()`
`254`		`- new MongoDbResultSetMetaData(collectionDao, data)`
	`254`	`+ new MongoDbResultSetMetaData(collectionDao, data, keySet)`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`override def getObject(columnIndex: Int): AnyRef = {`