test: changed all test from spec2 to munit

build.sbt

@@ -43,7 +43,7 @@ licenses += ("Apache-2.0", url("https://www.apache.org/licenses/LICENSE-2.0.html
 //crossScalaVersions := Seq("2.13.16")
 crossScalaVersions := Seq("3.6.0", "2.13.16")
 
-scalaVersion := crossScalaVersions.value.head
+scalaVersion := crossScalaVersions.value.last
 
 scalacOptions += "-deprecation"
 
@@ -60,12 +60,6 @@ buildInfoOptions += BuildInfoOption.BuildTime
 
 resolvers += "Sonatype OSS Snapshots".at("https://oss.sonatype.org/content/repositories/snapshots")
 
-// Test
-
-libraryDependencies += "org.specs2" %% "specs2-core" % "4.20.9" % Test
-
-libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.5.16" % Test
-
 libraryDependencies += "joda-time" % "joda-time" % "2.13.0"
 
 val circeVersion = "0.14.10"
@@ -96,14 +90,12 @@ libraryDependencies += "com.typesafe" % "config" % "1.4.3"
 
 libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.9.5"
 
-libraryDependencies += "org.scala-lang.modules" %% "scala-collection-compat" % "2.12.0"
+//libraryDependencies += "org.scala-lang.modules" %% "scala-collection-compat" % "2.12.0"
 
 libraryDependencies += "com.vdurmont" % "semver4j" % "3.1.0"
 
 libraryDependencies += "com.github.jsqlparser" % "jsqlparser" % "5.1"
 
-libraryDependencies += "org.liquibase" % "liquibase-core" % "4.31.0" % Test
-
 buildInfoPackage := "dev.mongocamp.driver.mongodb"
 
 buildInfoOptions += BuildInfoOption.BuildTime

build_test.sbt

@@ -0,0 +1,9 @@
+Test / parallelExecution := false
+
+libraryDependencies += "org.liquibase" % "liquibase-core" % "4.31.0" % Test
+
+// Test
+
+libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.5.16" % Test
+
+libraryDependencies += "org.scalameta" %% "munit" % "1.1.0"

docker.sh

@@ -1,10 +1,2 @@
 docker rm -f mongodb;
-docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest;
-
-
-#
-# [error] Error during tests:
-# [error]         dev.mongocamp.driver.mongodb.sync.SyncSpec
-# [error]         dev.mongocamp.driver.mongodb.sql.SelectSqlSpec
-# [error]         dev.mongocamp.driver.mongodb.dao.StudentDAOSpec
-# [error]         dev.mongocamp.driver.mongodb.sql.OtherSqlSpec
+docker run -d --publish 27017:27017 --name mongodb  mongocamp/mongodb:latest;

src/test/scala/dev/mongocamp/driver/mongodb/CompactSpec.scala

@@ -4,39 +4,38 @@ import better.files.{ File, Resource }
 import dev.mongocamp.driver.mongodb.database.CompactResult
 import dev.mongocamp.driver.mongodb.test.TestDatabase
 import dev.mongocamp.driver.mongodb.test.TestDatabase.BookDAO
-import org.specs2.mutable.Specification
-import org.specs2.specification.BeforeAll
+import munit.FunSuite
 
 import java.text.SimpleDateFormat
 import java.util.Date
 
-class CompactSpec extends Specification with BeforeAll {
+class CompactSpec extends FunSuite {
   val DateFormat = new SimpleDateFormat("yyyy-MM-dd")
   val From: Date = DateFormat.parse("2000-01-01")
 
   override def beforeAll(): Unit = {
+    super.beforeAll()
     BookDAO.drop().result()
     BookDAO.importJsonFile(File(Resource.getUrl("json/books.json"))).result()
     val stats = BookDAO.collectionStatus.result()
-    stats.count mustEqual 431
+    assertEquals(stats.count, 431)
   }
 
-  "CompactSpec" should {
-    "compact single collection" in {
-      val count: Option[CompactResult] = BookDAO.compact.result()
-      count.isDefined must beTrue
-      count.get.bytesFreed must beGreaterThanOrEqualTo(0L)
-    }
-    "compact complete database" in {
-      val count: List[CompactResult] = TestDatabase.provider.compactDatabase()
-      count.size must beGreaterThanOrEqualTo(1)
-      count.head.bytesFreed must beGreaterThanOrEqualTo(0L)
-    }
-    "compact all databases in scope" in {
-      val count: List[CompactResult] = TestDatabase.provider.compact()
-      count.size must beGreaterThanOrEqualTo(1)
-      count.head.bytesFreed must beGreaterThanOrEqualTo(0L)
-    }
+  test("compact single collection") {
+    val count: Option[CompactResult] = BookDAO.compact.result()
+    assertEquals(count.isDefined, true)
+    assertEquals(count.get.bytesFreed >= 0L, true)
   }
 
+  test("compact complete database") {
+    val count: List[CompactResult] = TestDatabase.provider.compactDatabase()
+    assertEquals(count.nonEmpty, true)
+    assertEquals(count.head.bytesFreed >= 0L, true)
+  }
+
+  test("compact all databases in scope") {
+    val count: List[CompactResult] = TestDatabase.provider.compact()
+    assertEquals(count.nonEmpty, true)
+    assertEquals(count.head.bytesFreed >= 0L, true)
+  }
 }

src/test/scala/dev/mongocamp/driver/mongodb/bson/BsonConverterSuite.scala

@@ -0,0 +1,93 @@
+package dev.mongocamp.driver.mongodb.bson
+
+import com.typesafe.scalalogging.LazyLogging
+import dev.mongocamp.driver.mongodb._
+import org.mongodb.scala.bson.collection.mutable
+import org.mongodb.scala.bson.{ ObjectId, _ }
+
+import scala.collection.mutable.ArrayBuffer
+
+class BsonConverterSuite extends munit.FunSuite {
+
+  test("BsonConverter convert values to BSON") {
+    assertEquals(BsonConverter.toBson(3), BsonInt32(3))
+    assertEquals(BsonConverter.toBson(3L), BsonInt64(3))
+    assertEquals(BsonConverter.toBson(3f), BsonDouble(3))
+    assertEquals(BsonConverter.toBson(3d), BsonDouble(3))
+
+    assertEquals(BsonConverter.toBson(false), BsonBoolean(false))
+    assertEquals(BsonConverter.toBson(true), BsonBoolean(true))
+
+    assertEquals(BsonConverter.toBson(java.math.BigDecimal.TEN), BsonDecimal128.apply(10))
+    assertEquals(BsonConverter.toBson(BigDecimal(10)), BsonDecimal128.apply(10))
+    assertEquals(BsonConverter.toBson(BigInt(10)), BsonInt64(10))
+    assertEquals(BsonConverter.toBson(java.math.BigInteger.TEN), BsonInt64(10))
+
+    assertEquals(BsonConverter.toBson(Some(5)), BsonInt32(5))
+
+    assertEquals(BsonConverter.toBson(Some(new ObjectId("5b61455932ac3f0015ae2e7e"))), BsonObjectId("5b61455932ac3f0015ae2e7e"))
+
+    assertEquals(BsonConverter.toBson(None), BsonNull())
+
+    assertEquals(BsonConverter.toBson('M'), BsonString("M"))
+  }
+
+  test("convert Map to BSON") {
+    assertEquals(BsonConverter.toBson(Map("test" -> 1)).isInstanceOf[org.bson.BsonDocument], true)
+    assertEquals(BsonConverter.toBson(scala.collection.mutable.Map("test" -> 1)).isInstanceOf[org.bson.BsonDocument], true)
+  }
+
+  test("convert List to BSON") {
+    assertEquals(BsonConverter.toBson(List("test")).isInstanceOf[org.bson.BsonArray], true)
+    val buffer = new ArrayBuffer[String]()
+    buffer.+=("Test")
+    assertEquals(BsonConverter.toBson(buffer).isInstanceOf[org.bson.BsonArray], true)
+  }
+
+  test("convert values from BSON") {
+    assertEquals(BsonConverter.fromBson(BsonInt32(3)), 3)
+    assertEquals(BsonConverter.fromBson(BsonInt64(3)), 3L)
+    assertEquals(BsonConverter.fromBson(BsonDouble(3)), 3.0)
+  }
+
+  test("evaluate dot notation") {
+    val document: mutable.Document = mutable.Document()
+    val secondLevelDocument        = mutable.Document()
+    secondLevelDocument.put("test", 42)
+    document.put("secondLevelDocument", secondLevelDocument)
+
+    assertEquals(document.get("secondLevelDocument").isDefined, true)
+    assertEquals(document.get("secondLevelDocument.test").isEmpty, true)
+
+    val v = BsonConverter.documentValueOption(Document(document.toJson()), "secondLevelDocument.test")
+    assertEquals(v.isDefined, true)
+
+  }
+
+  test("evaluate get with dot notation") {
+    val document: mutable.Document = mutable.Document()
+    val secondLevelDocument        = mutable.Document()
+    secondLevelDocument.put("test", 42)
+    document.put("secondLevelDocument", secondLevelDocument)
+
+    assertEquals(document.get("secondLevelDocument").isDefined, true)
+    assertEquals(document.get("secondLevelDocument.test"), None)
+
+    val v = BsonConverter.documentValueOption(Document(document.toJson()), "secondLevelDocument.test")
+
+    assertEquals(v.isDefined, true)
+  }
+
+  test("evaluate put with dot notation") {
+    val document = Document()
+
+    var updated: Document = BsonConverter.updateDocumentValue(document, "test", 42)
+
+    assertEquals(updated.getIntValue("test"), 42)
+
+    updated = BsonConverter.updateDocumentValue(document, "test.test.test.test", 42)
+
+    assertEquals(updated.getIntValue("test.test.test.test"), 42)
+  }
+
+}

src/test/scala/dev/mongocamp/driver/mongodb/bson/ConverterSuite.scala

@@ -0,0 +1,29 @@
+package dev.mongocamp.driver.mongodb.bson
+
+import dev.mongocamp.driver.mongodb.Converter
+import dev.mongocamp.driver.mongodb.model.Base
+
+class ConverterSuite extends munit.FunSuite {
+
+  test("Converter support Document roundtrip") {
+    val base = Base()
+    val document = Converter.toDocument(base)
+    val integer: Int = document.getInteger("int")
+    val long: Long = document.getLong("Long")
+    val float : Float = document.getDouble("float").floatValue()
+    val double : Double = document.getDouble("double")
+    val maybeBsonValue = document.get("option")
+
+    assertEquals(integer, base.int)
+    assertEquals(long, base.Long)
+    assertEquals(float, base.float)
+    assertEquals(double, base.double)
+    assertEquals(document.getString("string"), base.string)
+    assertEquals(document.getDate("date"), base.date)
+    assertEquals(maybeBsonValue.isDefined, true)
+    assertEquals(maybeBsonValue.get.asObjectId().getValue, base.option.get)
+    assertEquals(base != null, true)
+    assertEquals(base.isInstanceOf[Base], true)
+  }
+
+}