Writing functional tests with specs2

Writing functional tests with specs2

通过ScalaTest编写功能性测试

Play提供了一系列的类和简洁的方法来帮助实现功能性测试。大多数可以在play.api.test包或Helpers对象中找到。ScalaTest + Play集成库位ScalaTest构建了这种测试支持。

你可以通过以下的模块导入来访问所有的Play的内建测试支持和ScalaTest + Play:

  1. import org.scalatest._
  2. import play.api.test._
  3. import play.api.test.Helpers._
  4. import org.scalatestplus.play._

FakeApplication

Play经常性需要一个运行的Application作为上下文：其通常通过play.api.Play.current提供。

为了为测试提供一个环境，Play提供了一个FakeApplication类其可以和一个不同的Global对象，附加配置或附加的插件一起被配置。

  1. val fakeApplicationWithGlobal = FakeApplication(withGlobal = Some(new GlobalSettings() {
  2.       override def onStart(app: Application) { println("Hello world!") }
  3. }))

如果所有或大多数你的测试类需要一个FakeApplication,并且它们可以共享相同的FakeApplication,与OneAppPerSuite特性混合使用。你可以通过定制FakeApplication来如果这个例子展示的那样重写PP:

  1. class ExampleSpec extends PlaySpec with OneAppPerSuite {
  2.     //重写app如果你需要一个不仅有默认参数的FakeApplication。
  3.       implicit override lazy val app: FakeApplication =
  4.     FakeApplication(
  5.           additionalConfiguration = Map("ehcacheplugin" -> "disabled")
  6.     )
  8.       "The OneAppPerSuite trait" must {
  9.         "provide a FakeApplication" in {
  10.               app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  11.             }
  12.             "start the FakeApplication" in {
  13.                   Play.maybeApplication mustBe Some(app)
  14.                 }
  15.               }
  16.     }

如果你需要每个测试去获取它自己的FakeApplication而不是共享相同的，请使用OneAppPerTest来替代：

  1. class ExampleSpec extends PlaySpec with OneAppPerTest {
  2.     //重写app如果你需要一个不仅有默认参数的FakeApplication。
  3.       implicit override def newAppForTest(td: TestData): FakeApplication =
  4.     FakeApplication(
  5.           additionalConfiguration = Map("ehcacheplugin" -> "disabled")
  6.         )
  8.       "The OneAppPerTest trait" must {
  9.         "provide a new FakeApplication for each test" in {
  10.               app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  11.         }
  12.         "start the FakeApplication" in {
  13.               Play.maybeApplication mustBe Some(app)
  14.             }
  15.           }
  16.     }，

ScalaTest + Play提供了OneAppPerSuite和OneAppPerTest的原因是来允许你去选择共享性策略来让你的测试最快的运行。如果你想让应用状态在成功的测试之间保持，你将需要使用OneAppPerSuite.如果每个测试需要一个清空的状态，你可以使用OneAppPerTest或使用OneAppPerSuite,但需要在每个测试结束来清理状态。甚至，如果你的测试集将尽可能快的运行多个测试类共享这个相同的应用，你可以定义一个主集合起与OneAppPerSuite混用和内嵌的集合其和ConfiguredApp混用，正如在ConfiguredApp的文档中的例子展示的那样。你可以使用任意策略来实你的测试集最快的运行。

和一个服务器一起测试

有时候你想使用真的HTTP栈来进行测试。如果你的测试类中的所有测试能够重用这个相同的服务器实例，你可以通过与OneServerPerSuite一起混用（其将为这个集合提供一个新的FakeApplication）：

  1. class ExampleSpec extends PlaySpec with OneServerPerSuite {
  2.     // 重写app如果你需要一个不仅有默认参数的FakeApplication。
  3.       implicit override lazy val app: FakeApplication =
  4.     FakeApplication(
  5.           additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.           withRoutes = {
  7.             case ("GET", "/") => Action { Ok("ok") }
  8.           }
  9.     )
  11.   "test server logic" in {
  12.     val myPublicAddress =  s"localhost:$port"
  13.     val testPaymentGatewayURL = s"http://$myPublicAddress"
  14.     //这个测试支付网关在它返回一个值之前需要针对这个服务器的一个回调...
  15.     val callbackURL = s"http://$myPublicAddress/callback"
  16.     // 从play.api.test.FutureAwaits中等待调用
  17.     val response = await(WS.url(testPaymentGatewayURL).withQueryString("callbackURL" -> callbackURL).get())
  19.     response.status mustBe (OK)
  20.       }
  21. }

如果你的测试类中的所有测试需要不同的服务器实例，请使用OneServerPerTest来代替（其将同时为这个测试集提供一个新的FakeApplication）:

  1. class ExampleSpec extends PlaySpec with OneServerPerTest {
  2.     //重写newAppForTest如果你需要一个不仅有默认参数的FakeApplication.
  3.       override def newAppForTest(testData: TestData): FakeApplication =
  4.             new FakeApplication(
  5.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.               withRoutes = {
  7.                 case ("GET", "/") => Action { Ok("ok") }
  8.               }
  9.         )
  11.       "The OneServerPerTest trait" must {
  12.             "test server logic" in {
  13.                   val myPublicAddress =  s"localhost:$port"
  14.                   val testPaymentGatewayURL = s"http://$myPublicAddress"
  15.                 //测试支付网关在返回一个结果之前需要针对这个服务器的一个回调...
  16.                   val callbackURL = s"http://$myPublicAddress/callback"
  17.                   // await is from play.api.test.FutureAwaits
  18.                   val response = await(WS.url(testPaymentGatewayURL).withQueryString("callbackURL" -> callbackURL).get())
  20.                   response.status mustBe (OK)
  21.                 }
  22.               }
  23.         }

OneServerPerSuite和OneServerPerTest特性为该服务器运行为port域提供了port号。其默认是19001，甚至你可以通过重写端口或设定系统属性testserver.port来更改。其将非常有用当与持续集成服务器集成在一起，因此端口可以被动态的为每个构建所保留。

你同时可以如之前例子所展示的那样通过重写app来自定义FakeApplication.

最后，如果允许多个测试类来共享这个相同的服务器将会给你比OneServerPerSuite或OneServerPerTest方式更好的性能，正如ConfiguredServer文档中的例子所展示的那样，你可以定义一个主测试集其与OneServePerSuite混用和嵌入式测试集其与ConfiguredServer混用。

和一个网页浏览器一起测试

ScalaTest + Play库构基于Selenium DSL构建以使其简单的从网页浏览器中测试你的Play应用。
混合OneBrowserPerSuite到你的测试类中以便使用一个相同的浏览器来运行你的测试类中所有的测试。你将同时需要与一个BrowserFactory特性其将提供一个Selenium web驱动混用：ChromeFactory, FirefoxFactory, HtmlUnitFactory, InternetExplorerFactory, SafariFactory之一。

更进一步为了混合入一个BrowserFactory，你将需要混合进一个ServerProvider特性其提供了一个TestServer: ChromeFactory, FirefoxFactory, HtmlUnitFactory, InternetExplorerFactory, SafariFactory之一。

比如，以下的测试类混合进OneServerPerSuite和HtmUnitFactory:

  1. class ExampleSpec extends PlaySpec with OneServerPerSuite with OneBrowserPerSuite with HtmlUnitFactory {
  2.     //重写app如果你需要一个不仅有默认参数的FakeApplication.
  3.   implicit override lazy val app: FakeApplication =
  4.     FakeApplication(
  5.           additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.           withRoutes = {
  7.             case ("GET", "/testing") =>
  8.               Action(
  9.                 Results.Ok(
  10.                   "<html>" +
  11.                 "<head><title>Test Page</title></head>" +
  12.                 "<body>" +
  13.                 "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  14.                 "</body>" +
  15.                 "</html>"
  16.                 ).as("text/html")
  17.               )
  18.           }
  19.     )
  21.   "The OneBrowserPerTest trait" must {
  22.     "provide a web driver" in {
  23.           go to (s"http://localhost:$port/testing")
  24.           pageTitle mustBe "Test Page"
  25.           click on find(name("b")).value
  26.           eventually { pageTitle mustBe "scalatest" }
  27.         }
  28.       }
  29. }

如果你的每个测试需要一个新的浏览器实例，请使用OneBrowserPerTest来替代。比如OneBrowserPerSuite,你将需要同时与一个ServerProvider和BrowserFactory来混用:

  1. class ExampleSpec extends PlaySpec with OneServerPerTest with OneBrowserPerTest with HtmlUnitFactory {
  2.     //重写newAppForTest如果你需要一个不仅有默认参数的FakeApplication.
  3.       override def newAppForTest(testData: TestData): FakeApplication =
  4.         new FakeApplication(
  5.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.               withRoutes = {
  7.                 case ("GET", "/testing") =>
  8.                       Action(
  9.                         Results.Ok(
  10.                               "<html>" +
  11.                             "<head><title>Test Page</title></head>" +
  12.                             "<body>" +
  13.                             "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  14.                             "</body>" +
  15.                             "</html>"
  16.                         ).as("text/html")
  17.                       )
  18.                   }
  19.             )
  21.   "The OneBrowserPerTest trait" must {
  22.     "provide a web driver" in {
  23.           go to (s"http://localhost:$port/testing")
  24.           pageTitle mustBe "Test Page"
  25.           click on find(name("b")).value
  26.           eventually { pageTitle mustBe "scalatest" }
  27.         }
  28.       }
  29. }

如果你需要多个测试类来共享这个相同的浏览器实例，混合OneBrowserPerSuite进一个主测试集和混合ConfiguredBrowser进多个内嵌的测试集。内嵌的测试集将一起共享相同的浏览器。请参考ConfiguredBrowser特性的文档中的例子。

在多浏览器中运行相同的测试

如果你想在多浏览器中运行测试，以保证你的应用可以在所有你支持的浏览器中正常的工作，你可以使用AllBrowserPerSuite或AllBrowsersPerTest特性。这些特性都声明了一个IndexedSeq[BrowserInfo]特性和一个抽象的sharedTests方法其拥有一个BrowerInfo.browsers域指定了那个浏览器你想让你的测试在其中运行。默认的是Chrome, Firefox, Internet Explorer, HtmlUnit和Safari. 你可以重写browsers如果默认的不符合你的需求.你在sharedTests方法中嵌入你想在多浏览器中运行的测试，将浏览器的名字置于每个测试名的后面（浏览器名字是可用的从BrowserInfo传入进sharedTests.）这里有一个使用AllBrowsersPerSuite的例子：

  1. class ExampleSpec extends PlaySpec with OneServerPerSuite with AllBrowsersPerSuite {
  2.     //重写App如果你需要一个不仅有默认参数的FakeApplication.
  3.       implicit override lazy val app: FakeApplication =
  4.         FakeApplication(
  5.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.               withRoutes = {
  7.                 case ("GET", "/testing") =>
  8.                   Action(
  9.                     Results.Ok(
  10.                           "<html>" +
  11.                         "<head><title>Test Page</title></head>" +
  12.                         "<body>" +
  13.                         "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  14.                         "</body>" +
  15.                         "</html>"
  16.                     ).as("text/html")
  17.                   )
  18.               }
  19.         )
  21.       def sharedTests(browser: BrowserInfo) = {
  22.         "The AllBrowsersPerSuite trait" must {
  23.               "provide a web driver " + browser.name in {
  24.                 go to (s"http://localhost:$port/testing")
  25.                 pageTitle mustBe "Test Page"
  26.                 click on find(name("b")).value
  27.                 eventually { pageTitle mustBe "scalatest" }
  28.               }
  29.         }
  30.       }
  31. }

所有被sharedTests所声明的测试将被在browsers域中提到的所有浏览器一起运行，只要它们在客户端系统中是可用的。为任何浏览器其不存在于客户端系统的测试将会自动被取消。注意你需要手动的为测试名称追加browser.name以保障这个集合内的每个测试都有一个独立的名字（ScalaTest需要它）.如果你保留其空白，当你运行你的测试的时候将得到一个重复测试名字的错误。

AllBrowsersPerSuite 将为每种类型的浏览器创建一个单独的实例并为在sharedTests中声明的所有测试中使用。如果你想要每个测试去拥有它自己的，全新品牌的浏览器实例，请使用AllBrowsersPerTest来替代：

  1. class ExampleSpec extends PlaySpec with OneServerPerSuite with AllBrowsersPerTest {
  2.     //重写app如果你需要一个不仅有默认参数的FakeApplication.
  3.       implicit override lazy val app: FakeApplication =
  4.         FakeApplication(
  5.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.               withRoutes = {
  7.                 case ("GET", "/testing") =>
  8.                   Action(
  9.                     Results.Ok(
  10.                           "<html>" +
  11.                         "<head><title>Test Page</title></head>" +
  12.                         "<body>" +
  13.                         "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  14.                         "</body>" +
  15.                             "</html>"
  16.                     ).as("text/html")
  17.                   )
  18.               }
  19.         )
  21.       def sharedTests(browser: BrowserInfo) = {
  22.             "The AllBrowsersPerTest trait" must {
  23.               "provide a web driver"  + browser.name in {
  24.                 go to (s"http://localhost:$port/testing")
  25.                 pageTitle mustBe "Test Page"
  26.                 click on find(name("b")).value
  27.                 eventually { pageTitle mustBe     "scalatest" }
  28.               }
  29.             }
  30.       }
  31. }

尽管AllBrowserPerSuite和AllBrowsersPerTest都会针对不提供的浏览器类型而取消测试，这些测试
仍将在输出中显示为被取消。为了清理这些不必要的输出，你可以如下例子所示来通过重写browsers来排除那些永远不会被支持的网页浏览器：

  1. class ExampleOverrideBrowsersSpec extends PlaySpec with OneServerPerSuite with AllBrowsersPerSuite {
  3.       override lazy val browsers =
  4.         Vector(
  5.           FirefoxInfo(firefoxProfile),
  6.           ChromeInfo
  7.         )
  8.     //重写app如果你需要一个不仅有默认参数的FakeApplication.
  9.       implicit override lazy val app: FakeApplication =
  10.         FakeApplication(
  11.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  12.               withRoutes = {
  13.                 case ("GET", "/testing") =>
  14.                   Action(
  15.                     Results.Ok(
  16.                           "<html>" +
  17.                             "<head><title>Test Page</title></head>" +
  18.                          "<body>" +
  19.                         "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  20.                         "</body>" +
  21.                         "</html>"
  22.                         ).as("text/html")
  23.                       )
  24.                   }
  25.             )
  27.       def sharedTests(browser: BrowserInfo) = {
  28.         "The AllBrowsersPerSuite trait" must {
  29.               "provide a web driver"  + browser.name in {
  30.                         go to (s"http://localhost:$port/testing")
  31.                     pageTitle mustBe "Test Page"
  32.                     click on find(name("b")).value
  33.                     eventually { pageTitle mustBe "scalatest" }
  34.                   }
  35.             }
  36.           }
  37.     }

之前的测试类仅将尝试和Firefox，chrome一起运行共享的测试（并自动化的取消测试如果一个浏览器是不可用的）。

PlaySpec

PlaySpec为Play测试提供了一个便捷的“超集”ScalaTest基础类，你可以通过扩展
PlaySpec来自动得到WordSpec, MustMatchers, OptionValues, 和 WsScalaTestClient：

  1. class ExampleSpec extends PlaySpec with OneServerPerSuite with  ScalaFutures with IntegrationPatience {
  2.     //重写app如果你需要一个不仅有默认参数的FakeApplication.
  3.       implicit override lazy val app: FakeApplication =
  4.         FakeApplication(
  5.               additionalConfiguration = Map("ehcacheplugin" -> "disabled"),
  6.               withRoutes = {
  7.                 case ("GET", "/testing") =>
  8.                   Action(
  9.                     Results.Ok(
  10.                           "<html>" +
  11.                         "<head><title>Test Page</title></head>" +
  12.                         "<body>" +
  13.                         "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  14.                         "</body>" +
  15.                         "</html>"
  16.                         ).as("text/html")
  17.                       )
  18.                   }
  19.             )    
  20.       "WsScalaTestClient's" must {
  22.         "wsUrl works correctly" in {
  23.               val futureResult = wsUrl("/testing").get
  24.               val body = futureResult.futureValue.body
  25.               val expectedBody =
  26.                 "<html>" +
  27.                   "<head><title>Test Page</title></head>" +
  28.                   "<body>" +
  29.                   "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  30.                   "</body>" +
  31.                   "</html>"
  32.                   assert(body == expectedBody)
  33.             }
  35.         "wsCall works correctly" in {
  36.           val futureResult = wsCall(Call("get", "/testing")).get
  37.           val body = futureResult.futureValue.body
  38.           val expectedBody =
  39.             "<html>" +
  40.               "<head><title>Test Page</title></head>" +
  41.               "<body>" +
  42.               "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  43.               "</body>" +
  44.               "</html>"
  45.           assert(body == expectedBody)
  46.         }
  47.       }
  48. }

你可以将任何之前提到的特性混合进PlaySpec.
在之前例子中所展示的那些测试类中，测试类中的所有或大多数测试需要相同的样式。这个很常见但不总是这样。如果相同的测试类中不同的测试需要不同的样式，与特性MixedFixtures混用。然后使用这些无参功能: App, Server, Chrome, Firefox, HtmlUnit, InternetExplorer, 或 Safari之一来给予每个测试器需要的样式.
你不可以混合MixedFixtures进PlaySpec。因为MixedFixtures需要一个ScalaTest fixture.Suite但PlaySpec仅仅是一个不同的集合。如果你需要针对混合样式的一个简洁的基础类。通过扩展MixedPlaySpec来替代。这里是一个例子：

  1. // MixedPlaySpec 已经混合进MixedFixtures
  2. class ExampleSpec extends MixedPlaySpec {
  3. // 一些帮助器方法
  4.       def fakeApp[A](elems: (String, String)*) = FakeApplication(additionalConfiguration = Map(elems:_*),
  5.         withRoutes = {
  6.               case ("GET", "/testing") =>
  7.             Action(
  8.                   Results.Ok(
  9.                     "<html>" +
  10.                       "<head><title>Test Page</title></head>" +
  11.                       "<body>" +
  12.                       "<input type='button' name='b' value='Click Me' onclick='document.title=\"scalatest\"' />" +
  13.                       "</body>" +
  14.                       "</html>"
  15.                   ).as("text/html")
  16.             )
  17.         })
  18.       def getConfig(key: String)(implicit app: Application) = app.configuration.getString(key)
  19. // 如果一个测试进需要一个FakeApplication，使用"new APP"：
  20.       "The App function" must {
  21.         "provide a FakeApplication" in new App(fakeApp("ehcacheplugin" -> "disabled")) {
  22.           app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  23.         }
  24.         "make the FakeApplication available implicitly" in new App(fakeApp("ehcacheplugin" -> "disabled")) {
  25.               getConfig("ehcacheplugin") mustBe Some("disabled")
  26.         }
  27.         "start the FakeApplication" in new App(fakeApp("ehcacheplugin" -> "disabled")) {
  28.               Play.maybeApplication mustBe Some(app)
  29.         }
  30.       }
  31. // 如果一个测试需要一个FakeApplicaiton并运行TestServer,请使用"new Server":
  32.   "The Server function" must {
  33.     "provide a FakeApplication" in new Server(fakeApp("ehcacheplugin" -> "disabled"))     {
  34.           app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  35.         }
  36.     "make the FakeApplication available implicitly" in new Server(fakeApp("ehcacheplugin" -> "disabled")) {
  37.           getConfig("ehcacheplugin") mustBe Some("disabled")
  38.     }
  39.     "start the FakeApplication" in new Server(fakeApp("ehcacheplugin" -> "disabled")) {
  40.           Play.maybeApplication mustBe Some(app)
  41.     }
  42.     import Helpers._
  43.     "send 404 on a bad request" in new Server {
  44.           import java.net._
  45.           val url = new URL("http://localhost:" + port + "/boom")
  46.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  47.           try con.getResponseCode mustBe 404
  48.           finally con.disconnect()
  49.     }
  50.   }
  52. // 如果一个测试需要一个FakeApplication,运行TestServer，和Selenium HtmlUnit驱动请使用"new HtmlUnit"：
  53.   "The HtmlUnit function" must {
  54.     "provide a FakeApplication" in new HtmlUnit(fakeApp("ehcacheplugin" -> "disabled")) {
  55.       app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  56.     }
  57.     "make the FakeApplication available implicitly" in new HtmlUnit(fakeApp("ehcacheplugin" -> "disabled")) {
  58.           getConfig("ehcacheplugin") mustBe Some("disabled")
  59.     }
  60.     "start the FakeApplication" in new HtmlUnit(fakeApp("ehcacheplugin" -> "disabled")) {
  61.           Play.maybeApplication mustBe Some(app)
  62.     }
  63.     import Helpers._
  64.     "send 404 on a bad request" in new HtmlUnit {
  65.           import java.net._
  66.           val url = new URL("http://localhost:" + port + "/boom")
  67.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  68.           try con.getResponseCode mustBe 404
  69.           finally con.disconnect()
  70.     }
  71.     "provide a web driver" in new HtmlUnit(fakeApp()) {
  72.          go to ("http://localhost:" + port + "/testing")
  73.           pageTitle mustBe "Test Page"
  74.           click on find(name("b")).value
  75.           eventually { pageTitle mustBe "scalatest" }
  76.     }
  77.   }
  79. // 如果一个测试需要一个FakeApplication,运行TestServer,和Selenium Firefox驱动请使用"new Firefox"：
  80.   "The Firefox function" must {
  81.     "provide a FakeApplication" in new Firefox(fakeApp("ehcacheplugin" -> "disabled")) {
  82.       app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  83.     }
  84.     "make the FakeApplication available implicitly" in new Firefox(fakeApp("ehcacheplugin" -> "disabled")) {
  85.           getConfig("ehcacheplugin") mustBe Some("disabled")
  86.     }
  87.     "start the FakeApplication" in new Firefox(fakeApp("ehcacheplugin" -> "disabled")) {
  88.           Play.maybeApplication mustBe Some(app)
  89.     }
  90.     import Helpers._
  91.     "send 404 on a bad request" in new Firefox {
  92.           import java.net._
  93.           val url = new URL("http://localhost:" + port + "/boom")
  94.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  95.           try con.getResponseCode mustBe 404
  96.           finally con.disconnect()
  97.     }
  98.     "provide a web driver" in new Firefox(fakeApp()) {
  99.           go to ("http://localhost:" + port + "/testing")
  100.           pageTitle mustBe "Test Page"
  101.           click on find(name("b")).value
  102.           eventually { pageTitle mustBe "scalatest" }
  103.     }
  104.   }
  106. // // 如果一个测试需要一个FakeApplication,运行TestServer,和Selenium Safari驱动请使用"new Safari"：
  107.   "The Safari function" must {
  108.     "provide a FakeApplication" in new Safari(fakeApp("ehcacheplugin" -> "disabled")) {
  109.           app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  110.     }
  111.     "make the FakeApplication available implicitly" in new Safari(fakeApp("ehcacheplugin" -> "disabled")) {
  112.           getConfig("ehcacheplugin") mustBe Some("disabled")
  113.     }
  114.     "start the FakeApplication" in new Safari(fakeApp("ehcacheplugin" -> "disabled")) {
  115.           Play.maybeApplication mustBe Some(app)
  116.     }
  117.     import Helpers._
  118.     "send 404 on a bad request" in new Safari {
  119.           import java.net._
  120.           val url = new URL("http://localhost:" + port + "/boom")
  121.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  122.           try con.getResponseCode mustBe 404
  123.           finally con.disconnect()
  124.     }
  125.     "provide a web driver" in new Safari(fakeApp()) {
  126.           go to ("http://localhost:" + port + "/testing")
  127.           pageTitle mustBe "Test Page"
  128.           click on find(name("b")).value
  129.           eventually { pageTitle mustBe "scalatest" }
  130.     }
  131.   }
  133. // 如果一个测试需要一个FakeApplication,运行TestServer,和Selenium Chrome驱动请使用"new Chrome"：
  134.   "The Chrome function" must {
  135.     "provide a FakeApplication" in new Chrome(fakeApp("ehcacheplugin" -> "disabled")) {
  136.           app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  137.     }
  138.     "make the FakeApplication available implicitly" in new Chrome(fakeApp("ehcacheplugin" -> "disabled")) {
  139.           getConfig("ehcacheplugin") mustBe Some("disabled")
  140.     }
  141.     "start the FakeApplication" in new Chrome(fakeApp("ehcacheplugin" -> "disabled")) {
  142.           Play.maybeApplication mustBe Some(app)
  143.     }
  144.     import Helpers._
  145.     "send 404 on a bad request" in new Chrome {
  146.           import java.net._
  147.           val url = new URL("http://localhost:" + port + "/boom")
  148.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  149.           try con.getResponseCode mustBe 404
  150.           finally con.disconnect()
  151.     }
  152.     "provide a web driver" in new Chrome(fakeApp()) {
  153.           go to ("http://localhost:" + port + "/testing")
  154.           pageTitle mustBe "Test Page"
  155.           click on find(name("b")).value
  156.           eventually { pageTitle mustBe "scalatest" }
  157.     }
  158.   }
  160. // 如果一个测试需要一个FakeApplication,运行TestServer,和Selenium InternetExplorer驱动请使用"new InternetExplorer"：
  161.   "The InternetExplorer function" must {
  162.     "provide a FakeApplication" in new InternetExplorer(fakeApp("ehcacheplugin" -> "disabled")) {
  163.           app.configuration.getString("ehcacheplugin") mustBe Some("disabled")
  164.     }
  165.     "make the FakeApplication available implicitly" in new InternetExplorer(fakeApp("ehcacheplugin" -> "disabled")) {
  166.           getConfig("ehcacheplugin") mustBe Some("disabled")
  167.     }
  168.     "start the FakeApplication" in new InternetExplorer(fakeApp("ehcacheplugin" -> "disabled")) {
  169.       Play.maybeApplication mustBe Some(app)
  170.     }
  171.     import Helpers._
  172.     "send 404 on a bad request" in new InternetExplorer {
  173.           import java.net._
  174.           val url = new URL("http://localhost:" + port + "/boom")
  175.           val con = url.openConnection().asInstanceOf[HttpURLConnection]
  176.           try con.getResponseCode mustBe 404
  177.           finally con.disconnect()
  178.     }
  179.     "provide a web driver" in new InternetExplorer(fakeApp()) {
  180.           go to ("http://localhost:" + port + "/testing")
  181.           pageTitle mustBe "Test Page"
  182.           click on find(name("b")).value
  183.           eventually { pageTitle mustBe "scalatest" }
  184.     }
  185.   }
  187. // 如果一个测试不需要任何的特殊样式，仅需要写成"in { () => ... "
  188.   "Any old thing" must {
  189.     "be doable without much boilerplate" in { () =>
  190.        1 + 1 mustEqual 2
  191.      }
  192.   }
  193. }

测试一个模板

因为一个模板是一个标准的Scala功能，你可以从你的测试中执行它，并检测结果：

  1. "render index template" in new App {
  2.       val html = views.html.index("Coco")
  4.       contentAsString(html) must include ("Hello Coco")
  5. }

测试一个控制器

You can call any Action code by providing a FakeRequest:
你可以通过提供一个FakRequest来调用任何Action代码：

  1. import scala.concurrent.Future
  3. import org.scalatest._
  4. import org.scalatestplus.play._
  6. import play.api.mvc._
  7. import play.api.test._
  8. import play.api.test.Helpers._
  10. class ExampleControllerSpec extends PlaySpec with Results {
  12.       class TestController() extends Controller with ExampleController
  14.       "Example Page#index" should {
  15.         "should be valid" in {
  16.               val controller = new TestController()
  17.               val result: Future[SimpleResult] = controller.index().apply(FakeRequest())
  18.               val bodyText: String = contentAsString(result)
  19.               bodyText mustBe "ok"
  20.             }
  21.           }
  22.     }

技术上讲，在这里你不需要WithApption,尽管使用它并不会产生任何不利影响。

测试一个路由

你可以通过让Router来做而不是你自己来调用Action：

  1. "respond to the index Action" in new App(fakeApplication) {
  2.       val Some(result) = route(FakeRequest(GET, "/Bob"))
  4.       status(result) mustEqual OK
  5.       contentType(result) mustEqual Some("text/html")
  6.       charset(result) mustEqual Some("utf-8")
  7.       contentAsString(result) must include ("Hello Bob")
  8. }

测试一个模块

如果你使用一个SQL数据库，你可以通过使用inMemoryDatabase来用一个H2数据库的内存实例替换数据库连接。

val appWithMemoryDatabase = FakeApplication(additionalConfiguration = inMemoryDatabase("test"))
"run an application" in new App(appWithMemoryDatabase) {

      val Some(macintosh) = Computer.findById(21)

      macintosh.name mustEqual "Macintosh"
      macintosh.introduced.value mustEqual "1984-01-24"
}

测试WS调用

如果你正在调用一个网页服务，你可以使用WSTestClinet.这里两个调用可用，wsCall和wsUrl其将分别执行一个调用或字符串。注意他们期望在WithApplication的上下文里被调用。

wsCall(controllers.routes.Application.index()).get()

wsUrl("http://localhost:9000").get()