feat: Implicit for LuceneQuery to BsonDocument

src/main/scala/dev/mongocamp/driver/DocumentIncludes.scala

@@ -3,6 +3,8 @@ package dev.mongocamp.driver
 import dev.mongocamp.driver.mongodb.Converter
 import dev.mongocamp.driver.mongodb.bson.BsonConverter
 import dev.mongocamp.driver.mongodb.database.DatabaseProvider
+import dev.mongocamp.driver.mongodb.lucene.LuceneQueryConverter
+import org.apache.lucene.search.Query
 import org.bson.types.ObjectId
 import org.mongodb.scala.Document
 import org.mongodb.scala.bson.conversions.Bson
@@ -12,6 +14,8 @@ import scala.language.implicitConversions
 trait DocumentIncludes {
   implicit def mapToBson(value: Map[_, _]): Bson = Converter.toDocument(value)
 
+  implicit def luceneQueryBson(query: Query): Bson = LuceneQueryConverter.toDocument(query)
+
   implicit def documentFromJavaMap(map: java.util.Map[String, Any]): Document =
     documentFromScalaMap(map.asScala.toMap)
 

src/main/scala/dev/mongocamp/driver/MongoImplicits.scala

@@ -11,18 +11,15 @@ trait MongoImplicits extends ObservableIncludes with ObservableImplicits {
 
   implicit def observableToResult[T](obs: Observable[T]): T = obs.result()
 
-  implicit def findObservableToResultList[T](obs: FindObservable[T]): List[T] =
-    obs.resultList()
+  implicit def findObservableToResultList[T](obs: FindObservable[T]): List[T] = obs.resultList()
 
   implicit def findObservableToResultOption[T](obs: FindObservable[T]): Option[T] = obs.resultOption()
 
   // gridfs
 
-  implicit def gridFSFindObservableToFiles(observable: GridFSFindObservable): List[GridFSFile] =
-    observable.resultList()
+  implicit def gridFSFindObservableToFiles(observable: GridFSFindObservable): List[GridFSFile] = observable.resultList()
 
-  implicit def gridFSFileToObjectId(file: GridFSFile): ObjectId =
-    file.getObjectId
+  implicit def gridFSFileToObjectId(file: GridFSFile): ObjectId = file.getObjectId
 
   implicit def gridFSFileToBSonIdValue(file: GridFSFile): BsonValue = file.getId
 

src/main/scala/dev/mongocamp/driver/mongodb/lucene/LuceneQueryConverter.scala

@@ -16,7 +16,7 @@ import scala.jdk.CollectionConverters._
 
 object LuceneQueryConverter extends LazyLogging {
 
-  def getMongoDbSearch(query: Query): Bson = {
+  def toDocument(query: Query): Bson = {
     getMongoDbSearchMap(query, false)
   }
 

src/main/scala/dev/mongocamp/driver/mongodb/package.scala

@@ -13,8 +13,7 @@ package object mongodb extends ObservableIncludes with DocumentIncludes {
 
   implicit class DocumentExtensions[A <: Document](val document: A) extends AnyVal {
 
-    def asPlainMap: Map[String, Any] =
-      BsonConverter.asMap(document)
+    def asPlainMap: Map[String, Any] = BsonConverter.asMap(document)
 
     def asPlainJson: String = {
       val builder = JsonWriterSettings.builder
@@ -27,11 +26,12 @@ package object mongodb extends ObservableIncludes with DocumentIncludes {
 
     def getValue(key: String): Any = getValueOption(key).orNull
 
-    def getStringValue(key: String): String =
+    def getStringValue(key: String): String = {
       getValue(key) match {
         case n: Any => n.toString
         case _      => ""
       }
+    }
 
     def getLongValue(key: String): Long = {
       val value = getValue(key)
@@ -44,12 +44,13 @@ package object mongodb extends ObservableIncludes with DocumentIncludes {
 
     def getIntValue(key: String): Int = getLongValue(key).intValue()
 
-    def getDoubleValue(key: String): Double =
+    def getDoubleValue(key: String): Double = {
       getValue(key) match {
         case n: Number => n.doubleValue()
         case s: String => s.toDouble
         case _         => 0
       }
+    }
 
     def getDateValue(key: String): Date = {
       val value = getValue(key)

src/test/scala/dev/mongocamp/driver/mongodb/lucene/LuceneSearchSpec.scala

@@ -11,15 +11,23 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "search with extended query" in {
       val luceneQuery = LuceneQueryConverter.parse("(favoriteFruit:\"apple\" AND age:\"25\") OR name:*Cecile* AND -active:false AND 123", "id")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
+      search must haveSize(1)
+      search.head.age mustEqual 25
+      search.head.name mustEqual "Terra Salinas"
+    }
+
+    "search with extended query use implicit" in {
+      val luceneQuery = LuceneQueryConverter.parse("(favoriteFruit:\"apple\" AND age:\"25\") OR name:*Cecile* AND -active:false AND 123", "id")
+      val search      = PersonDAO.find(luceneQuery, sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 25
       search.head.name mustEqual "Terra Salinas"
     }
 
     "between filter for number value" in {
       val luceneQuery = LuceneQueryConverter.parse("[1010 TO 1052.3]", "balance")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(3)
       search.head.age mustEqual 28
       search.head.name mustEqual "Mason Donaldson"
@@ -28,7 +36,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "between filter for number value not" in {
       val luceneQuery = LuceneQueryConverter.parse("-[1010 TO 1052.3]", "balance")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(197)
       search.head.age mustEqual 29
       search.head.balance mustEqual 3996.0
@@ -37,7 +45,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "between filter for date value" in {
       val luceneQuery = LuceneQueryConverter.parse("[2014-04-20T00:00:00Z TO 2014-04-22T23:59:59Z]", "registered")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(10)
       search.head.age mustEqual 25
       search.head.name mustEqual "Allison Turner"
@@ -46,7 +54,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "equals Query with Date" in {
       val luceneQuery = LuceneQueryConverter.parse("registered:20140420T004427000+0200", "unbekannt")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 31
       search.head.name mustEqual "Latasha Mcmillan"
@@ -55,7 +63,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "wildcard at the end" in {
       val luceneQuery = LuceneQueryConverter.parse("Latasha*", "name")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 31
       search.head.name mustEqual "Latasha Mcmillan"
@@ -64,7 +72,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "wildcard at the start" in {
       val luceneQuery = LuceneQueryConverter.parse("*Mcmillan", "name")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 31
       search.head.name mustEqual "Latasha Mcmillan"
@@ -73,13 +81,13 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "not wildcard at the start" in {
       val luceneQuery = LuceneQueryConverter.parse("-name:*Mcmillan", "ube")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(199)
     }
 
     "wildcard at the start and end" in {
       val luceneQuery = LuceneQueryConverter.parse("*Mcmil*", "name")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 31
       search.head.name mustEqual "Latasha Mcmillan"
@@ -88,13 +96,13 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "not wildcard at the start and end" in {
       val luceneQuery = LuceneQueryConverter.parse("-name:*Mcmil*", "ube")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(199)
     }
 
     "wildcard in the middle" in {
       val luceneQuery = LuceneQueryConverter.parse("\"Latasha *millan\"", "name")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(1)
       search.head.age mustEqual 31
       search.head.name mustEqual "Latasha Mcmillan"
@@ -103,7 +111,7 @@ class LuceneSearchSpec extends PersonSpecification {
 
     "not wildcard in the middle" in {
       val luceneQuery = LuceneQueryConverter.parse("-name:\"Latasha*millan\"", "ube")
-      val search      = PersonDAO.find(LuceneQueryConverter.getMongoDbSearch(luceneQuery), sortByBalance).resultList()
+      val search      = PersonDAO.find(LuceneQueryConverter.toDocument(luceneQuery), sortByBalance).resultList()
       search must haveSize(199)
     }
   }

src/test/scala/dev/mongocamp/driver/mongodb/pagination/PaginationAggregationSpec.scala

@@ -31,6 +31,8 @@ class PaginationAggregationSpec extends PersonSpecification {
 
       val page = pagination.paginate(1, 10)
 
+      (pagination.countResult must be).equalTo(98)
+
       (page.paginationInfo.allCount must be).equalTo(98)
 
       (page.paginationInfo.pagesCount must be).equalTo(10)
@@ -46,7 +48,8 @@ class PaginationAggregationSpec extends PersonSpecification {
 
       val page = pagination.paginate(1, 10)
 
-      // #agg_execute
+      (pagination.countResult must be).equalTo(21)
+
       (page.paginationInfo.allCount must be).equalTo(21)
 
       (page.paginationInfo.pagesCount must be).equalTo(3)

src/test/scala/dev/mongocamp/driver/mongodb/pagination/PaginationFilterSpec.scala

@@ -15,7 +15,9 @@ class PaginationFilterSpec extends PersonSpecification with MongoImplicits {
 
       val page = pagination.paginate(1, 10)
 
-      (page.paginationInfo.allCount must be).equalTo(PersonDAO.count().result().toInt)
+      val personCollectionCount = PersonDAO.count().result().toInt
+      page.paginationInfo.allCount mustEqual personCollectionCount
+      pagination.countResult mustEqual personCollectionCount
 
       page.databaseObjects.size must beEqualTo(10)
 
@@ -30,6 +32,7 @@ class PaginationFilterSpec extends PersonSpecification with MongoImplicits {
 
       val pageFemale = paginationFemale.paginate(1, 10)
 
+      paginationFemale.countResult mustEqual 11
       pageFemale.paginationInfo.pagesCount mustEqual 10
       pageFemale.paginationInfo.allCount mustEqual 98
       pageFemale.paginationInfo.page mustEqual 1
@@ -41,6 +44,7 @@ class PaginationFilterSpec extends PersonSpecification with MongoImplicits {
       val paginationMales = MongoPaginatedFilter(PersonDAO, Map("gender" -> "male"))
       val pageMale        = paginationMales.paginate(1, 10)
 
+      paginationMales.countResult mustEqual 11
       pageMale.paginationInfo.pagesCount mustEqual 11
       pageMale.paginationInfo.allCount mustEqual 102
       pageMale.paginationInfo.page mustEqual 1