Question

我的控制器中有一个方法，我想直接打电话。它接受一个POSTed表单，验证它，然后返回一些东西。我想直接测试它 - 即不通过路线助手。

这是我的表单代码（FormFields只是一个案例类）

val searchForm = Form(
  mapping(
   "foo" -> nonEmptyText,
   "filter" -> optional(text).verifying("Filter text must be 'published' or 'unpublished'",
     x => x.isEmpty || x.get == "published" || x.get == "unpublished")
 )(FormFields.apply)(FormFields.unapply)

）

这是我的控制器电话。

def doThings() = IsAuthenticated {
   username => implicit request => {
    searchForm.bindFromRequest().fold(
      formWithErrors => BadRequest(s"Incorrect data: ${formWithErrors.errors.map(x => s"${x.key} ${x.message}").mkString}."),
      form => {
            OK("Test text here")
      }
    )
  }

}

如果我通过我的路线文件调用此方法，如下所示 - 这可以按预期工作。表格被发布，验证，按预期返回OK（“测试...”）。

即。以下工作（使用Specs2）

        val request = FakeRequest(POST, "notarealurl")
          .withFormUrlEncodedBody(
          "filter" -> "published",
          "foo" -> "Test"
    ).withSession("email" -> "testuser")

    val Some(result) = route(request)
    status(result) must equalTo(OK)

然而，无论我试图直接调用该方法失败 - 失败发生在表单验证步骤。它告诉我，当我运行单元测试时，“foo”缺少一个值。这就是我试图这样做的方式。

    val request = FakeRequest()
      .withFormUrlEncodedBody(
      "filter" -> "published",
      "foo" -> "Test"
    ).withSession("email" -> "testuser")


    //val Some(result) = route(request)
    val result = Search.searchProducts()(request)

    println(contentAsString(result))
    status(result) must equalTo(OK)

打印的文字是“搜索不正确：foo error.required”。我想我没有正确地打电话，但我不知道我哪里出错了。

注意：这里的代码代表了我的问题，但已被简化为只是为了说明问题。

Answer 1

我模仿你的逻辑，它运行良好。我用Play文档中的复制粘贴替换了一些代码，只是为了保持最小化。我在我正在进行的设置之上测试了它所以你会看到默认播放设置的异物。此设置与我最初链接的文章中描述的设置或多或少相同。我不知道怎么比这更直接：

在控制器中：

import play.api.data._
import play.api.data.Forms._
case class UserData(name: String, age: Int)
val userFormConstraints2 = Form(
  mapping(
    "name" -> nonEmptyText,
    "age" -> number(min = 0, max = 100)
  )(UserData.apply)(UserData.unapply)
)
def test = Action {
  implicit request => {
    userFormConstraints2.bindFromRequest().fold(
      formWithErrors => BadRequest("bad"),
      userData => {
        Ok(userData.name + userData.age)
      }
    )
  }
}

测试：

class TempSpec extends Specification with MyHelpers {
  "1" can {
    "direct access to controller while posting" in new TestServer {
                        // `in new TestServer` spawns dependencies (`server`)
      val controller = new controllers.Kalva(server)
                        // I instantiate the controller passing the dependency
      val request = FakeRequest(POST, "bla")
        .withFormUrlEncodedBody(
          "name" -> "Richard",
          "age" -> "1"
        )
      val result = controller.test()(request)
      status(result) must equalTo(OK)
      contentAsString(result) must contain("Richard");
      val request_bad = FakeRequest(POST, "bla")
        .withFormUrlEncodedBody(
          "name" -> "",
          "age" -> "-1"
        )
      val result_bad = controller.test()(request_bad)
      status(result_bad) must equalTo(400)
      contentAsString(result_bad) must contain("bad");
    }
  }
}

Global.scala：

object Global extends GlobalSettings {
  private lazy val injector = Guice.createInjector(new TestModule)

  override def getControllerInstance[A](controller: Class[A]) = {
    injector.getInstance(controller)
  }
}

TestModule：

import com.google.inject._
import com.tzavellas.sse.guice.ScalaModule
class TestModule extends ScalaModule {
  def configure() {
    @Provides
    def getServer:Server = {
      ...
    }
  }
}

在routes档案中：

POST    /bla                        @controllers.Kalva.test
               // the `@` prefix is needed because of how we fetch controllers

以下原始答案：

class TranslateSpec extends Specification {

  "Translate" should {
    // The normal Play! way
    "accept a name, and return a proper greeting" in {
      running(FakeApplication()) {
        val translated = route(FakeRequest(GET, "/greet/Barney")).get

        status(translated) must equalTo(OK)
        contentType(translated) must beSome.which(_ == "text/html")
        contentAsString(translated) must contain ("Barney")  
      }
    }

      // Providing a fake Global, to explitly mock out the injector
    object FakeTranslatorGlobal extends play.api.GlobalSettings {
      override def getControllerInstance[A](clazz: Class[A]) = {
        new Translate(new FakeTranslator).asInstanceOf[A]
      }
    }
    "accept a name, and return a proper greeting (explicitly mocking module)" in {
      running(FakeApplication(withGlobal = Some(FakeTranslatorGlobal))) {
        val home = route(FakeRequest(GET, "/greet/Barney")).get
        contentAsString(home) must contain ("Hello Barney")
      }
    }

    // Calling the controller directly, without creating a new FakeApplication
    // (This is the fastest)
    "accept a name, and return a proper greeting (controller directly, no FakeApplication!)" in {
      val controller = new Translate(new FakeTranslator)
      val result = controller.greet(name = "Barney")(FakeRequest())
      contentAsString(result) must contain ("Hello Barney")
    }
  }
}

上面的代码非常具有自我描述性，它显示了默认的测试工作流程以及如何使用依赖注入来改进它。这是this article的引用。

这个特别摘录来自“我为什么要在游戏中使用DI？”部分。这篇文章是关于使用Play2设置Google Guice以及它打开的可能性。这是一本实用的阅读。

正如您在上面所看到的那样，“正常的Play！方式”很好，但是通过接受DI，您可以在测试中获得更多（当然还有开发）。

正如文章中所描述的，使用Guice with Play涉及对Play的默认设置进行细微更改，这非常值得。我已经这么做了很长时间了，并没有回头。

Play Framework，Specs2 - 直接从单元测试调用控制器方法

1 个答案:

以下原始答案：