feat: Compact Method for complete user scope

Author: QuadStingray

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

@@ -12,6 +12,7 @@ import org.mongodb.scala.model.Projections
 import org.mongodb.scala.{BulkWriteResult, Document, MongoCollection, Observable, SingleObservable}
 
 import java.nio.charset.Charset
+import java.util.Date
 import scala.collection.mutable.ArrayBuffer
 import scala.reflect.ClassTag
 
@@ -35,7 +36,10 @@ abstract class MongoDAO[A](provider: DatabaseProvider, collectionName: String)(i
   }
 
   def compact: Observable[Option[CompactResult]] = {
-    provider.runCommand(Map("compact" -> collectionName)).map(document => CompactResult(document))
+    val startDate = new Date()
+    provider
+      .runCommand(Map("compact" -> collectionName))
+      .map(document => CompactResult(s"$databaseName${DatabaseProvider.CollectionSeparator}$collectionName", document, startDate))
   }
 
   /** @param sampleSize

src/main/scala/dev/mongocamp/driver/mongodb/database/CompactResult.scala

@@ -2,14 +2,18 @@ package dev.mongocamp.driver.mongodb.database
 import dev.mongocamp.driver.mongodb._
 import org.mongodb.scala.bson.Document
 
-case class CompactResult(bytesFreed: Long)
+import java.util.Date
+
+case class CompactResult(collectionName: String, bytesFreed: Long, duration: Long)
 
 object CompactResult {
-  def apply(document: Document): Option[CompactResult] = {
+  def apply(collectionName: String, document: Document, startDate: Date): Option[CompactResult] = {
     if (document.getLongValue("ok") == 1) {
       Some(
         CompactResult(
-          document.getLongValue("bytesFreed")
+          collectionName,
+          document.getLongValue("bytesFreed"),
+          new Date().getTime - startDate.getTime
         )
       )
     }

src/main/scala/dev/mongocamp/driver/mongodb/database/DatabaseProvider.scala

@@ -42,13 +42,16 @@ class DatabaseProvider(val config: MongoConfig, val registry: CodecRegistry) ext
 
   def dropDatabase(databaseName: String = DefaultDatabaseName): SingleObservable[Void] = database(databaseName).drop()
 
-  def compact(databaseName: String = DefaultDatabaseName, maxWaitPerCollection: Int = DefaultMaxWait): CompactResult = {
-    CompactResult(
-      collectionNames(databaseName)
-        .map(
-        collectionName => dao(collectionName).compact.result(maxWaitPerCollection).getOrElse(CompactResult(0)))
-        .map(_.bytesFreed)
-        .sum
+  def compactDatabase(databaseName: String = DefaultDatabaseName, maxWaitPerCollection: Int = DefaultMaxWait): List[CompactResult] = {
+    collectionNames(databaseName).flatMap(collectionName => dao(collectionName).compact.result(maxWaitPerCollection))
+  }
+
+  def compact(maxWaitPerCollection: Int = DefaultMaxWait): List[CompactResult] = {
+    databaseNames.flatMap(database =>
+      try collectionNames(database).flatMap(collectionName => dao(collectionName).compact.result(maxWaitPerCollection))
+      catch {
+        case e: MongoCommandException => List()
+      }
     )
   }
 

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

@@ -28,8 +28,14 @@ class CompactSpec extends Specification with BeforeAll {
       count.get.bytesFreed must beGreaterThanOrEqualTo(0L)
     }
     "compact complete database" in {
-      val count: CompactResult = TestDatabase.provider.compact()
-      count.bytesFreed must beGreaterThanOrEqualTo(0L)
+      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)
     }
   }