在 Playframework 2.4 中为 ReactiveMongoApi 编写 ScalaTest？答案

【问题标题】：Writing ScalaTest for ReactiveMongoApi in Playframework 2.4?在 Playframework 2.4 中为 ReactiveMongoApi 编写 ScalaTest？
【发布时间】：2015-12-24 18:48:33
【问题描述】：

我正在尝试在我的 play 应用程序中为 mongodb 编写测试。

我似乎无法正常工作，因为在执行保存之前连接已关闭。

这是结果

[info] UserDaoMongoSpec:
[info] UserDao
[info] - application - ReactiveMongoApi starting...
[info] - application - ReactiveMongoApi successfully started with DB 'test'! Servers:
            [localhost:27017]
[info] - should save users and find them by userId
[info] - application - ReactiveMongoApi stopping...
[info] - application - ReactiveMongoApi connections stopped. [Success(Closed)]
[INFO] [12/24/2015 15:36:43.961] [reactivemongo-akka.actor.default-dispatcher-4] [akka://reactivemongo/user/Monitor-3] Message [reactivemongo.core.actors.Close$] from Actor[akka://reactivemongo/deadLetters] to Actor[akka://reactivemongo/user/Monitor-3#1192398481] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
[info] ScalaTest
[info] Run completed in 3 seconds, 989 milliseconds.
[info] Total number of tests run: 1
[info] Suites: completed 1, aborted 0
[info] Tests: succeeded 1, failed 0, canceled 0, ignored 0, pending 0
[info] All tests passed.
[info] Passed: Total 1, Failed 0, Errors 0, Passed 1

这是测试的代码，没有测试任何东西，但我正在尝试先写数据库。

package test.daos

import scala.concurrent.ExecutionContext.Implicits.global

import daos.impl.UserDaoMongo

import org.scalatest._
import play.api.test._
import play.api.test.Helpers._
import org.scalatestplus.play._

class UserDaoMongoSpec extends DaosApplicationSpecOneAppPerTest {

  "UserDao" should {
    "save users and find them by userId" in {
      val userDao = new UserDaoMongo
      val future = for {
        _ <- userDao.save(credentialsTestUser)
        maybeUser <- userDao.find(credentialsTestUser.id)
      } yield maybeUser.map(_ == credentialsTestUser)
    }
  }

}

以及dao实现

package daos.impl

import java.util.UUID

import scala.concurrent.Future

import play.api.Play.current
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json

import play.modules.reactivemongo.ReactiveMongoApi
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.json.collection.JSONCollection

import com.mohiva.play.silhouette.api.LoginInfo

import models.{User, Profile}
import models.User._

import daos.api.UserDao

import play.api.Logger

class UserDaoMongo extends UserDao {
  lazy val reactiveMongoApi = current.injector.instanceOf[ReactiveMongoApi]
  val users = reactiveMongoApi.db.collection[JSONCollection]("users")

  def find(loginInfo:LoginInfo):Future[Option[User]] =
    users.find(Json.obj("profiles.loginInfo" -> loginInfo)).one[User]

  def find(userId:UUID):Future[Option[User]] ={
    Logger.debug("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
    users.find(Json.obj("id" -> userId)).one[User]
  }

  def save(user:User):Future[User] =
    users.insert(user).map(_ => user)

  def confirm(loginInfo:LoginInfo):Future[User] = for {
    _ <- users.update(Json.obj(
      "profiles.loginInfo" -> loginInfo
    ), Json.obj("$set" -> Json.obj("profiles.$.confirmed" -> true)))
    user <- find(loginInfo)
  } yield user.get

  def link(user:User, profile:Profile) = for {
    _ <- users.update(Json.obj(
      "id" -> user.id
    ), Json.obj("$push" -> Json.obj("profiles" -> profile)))
    user <- find(user.id)
  } yield user.get

  def update(profile:Profile) = for {
    _ <- users.update(Json.obj(
      "profiles.loginInfo" -> profile.loginInfo
    ), Json.obj("$set" -> Json.obj("profiles.$" -> profile)))
    user <- find(profile.loginInfo)
  } yield user.get
}

我做错了什么？

谢谢

【问题讨论】：

您需要指出是哪个代码引发了问题。
感谢@cchantep 的快速回答。
您不会等待测试执行后可能（似乎）完成的Futures。要么您使用一些 scalatest 特定功能来使测试等待期货完成，要么您自己 Await.result。
@cchantep 谢谢。事实证明你是对的。我让它与 Await.result 一起工作。请张贴作为答案，我标记为正确答案。
顺便说一句，它也适用于 scalatest 特定功能 whenReady，但我不得不更改默认超时设置。

标签： scala scalatest reactivemongo

【解决方案1】：

正如 cmets 中所说，事实证明错误在于我没有等待未来的完成。我决定使用 ScalaTest 特定函数来让测试等待期货完成

这里是代码

"UserDao" should {

  "save users and find them by userId" in withUserDao { userDao =>
    val future = for {
      user <- userDao.save(credentialsTestUser)
      maybeUser <- userDao.find(credentialsTestUser.id)
    } yield {
      maybeUser.map(_ == credentialsTestUser)
    }
    whenReady (future) { result =>
      result.get must be (true)
    }
  }
}

为了以防万一，我覆盖了默认行为，因为默认时间不够

implicit override val patienceConfig =
  PatienceConfig(timeout = Span(2, Seconds), interval = Span(5, Millis))

谢谢

【讨论】：