AllBrowsersPerTest

Trait that uses a shared test approach to enable you to run the same tests on multiple browsers in a ScalaTest Suite, where a new browser is started before each test that needs a browser, and stopped after.

Note: the difference between this trait and AllBrowsersPerSuite is that AllBrowsersPerSuite will allow you to write tests that rely on maintaining browser state between the tests. Thus, AllBrowsersPerSuite is a good fit for integration tests in which each test builds on actions taken by the previous tests. This trait is good if your tests each need a brand new browser.

This trait overrides Suite's withFixture lifecycle method to create a new WebDriver instance before executing each test that needs a browser, closing it after the test completes, and overrides the tags lifecycle method to tag the shared tests so you can filter them by browser type. This trait's self-type, ServerProvider, will ensure a TestServer and Application are available to each test. The self-type will require that you mix in either GuiceOneServerPerSuite, GuiceOneServerPerTest, ConfiguredServer before you mix in this trait. Your choice among these three ServerProviders will determine the extent to which a TestServer is shared by multiple tests.

You'll need to place any tests that you want executed by multiple browsers in a sharedTests method. Because all tests in a ScalaTest Suite must have unique names, you'll need to append the browser name (available from the BrowserInfo passed to sharedTests) to each test name:

def sharedTests(browser: BrowserInfo) {
  "The blog app home page" must {
    "have the correct title " + browser.name in {
       go to (host + "index.html")
       pageTitle must be ("Awesome Blog")
    }

All tests registered via sharedTests will be registered for each desired WebDriver, as specified by the browsers field. When running, any tests for browser drivers that are unavailable on the current platform will be canceled. All tests registered under sharedTests will be tagged automatically if they end with a browser name in square brackets. For example, if a test name ends with [Firefox], it will be automatically tagged with "org.scalatest.tags.FirefoxBrowser". This will allow you can include or exclude the shared tests by browser type using ScalaTest's regular tagging feature.

You can use tagging to include or exclude browsers that you sometimes want to test with, but not always. If you never want to test with a particular browser, you can prevent tests for it from being registered at all by overriding browsers and excluding its BrowserInfo in the returned Seq. For example, to disable registration of tests for HtmlUnit, you'd write:

override lazy val browsers: IndexedSeq[BrowserInfo] =
  Vector(
    FirefoxInfo,
    SafariInfo,
    InternetExplorerInfo,
    ChromeInfo
  )

Note that this trait can only be mixed into traits that register tests as functions, as the shared tests technique is not possible in style traits that declare tests as methods, such as org.scalatest.Spec. Attempting to do so will become a type error once we release ScalaTest 2.2.0.

package org.scalatestplus.play.examples.allbrowserspertest

import org.scalatest._
import org.scalatestplus.play._
import play.api.{Play, Application}
import play.api.inject.guice._
import play.api.routing._
import play.api.cache.ehcache.EhCacheModule

class ExampleSpec extends PlaySpec with OneServerPerTest with AllBrowsersPerTest {

  // Override newAppForTest if you need a Application with other than non-default parameters.
  override def newAppForTest(testData: TestData): Application = new GuiceApplicationBuilder()
    .disable[EhCacheModule]
    .configure("foo" -> "bar")
    .router(TestRoutes.router)
    .build()

  // Place tests you want run in different browsers in the `sharedTests` method:
  def sharedTests(browser: BrowserInfo) = {

    "The AllBrowsersPerTest trait" must {
      "provide a web driver " + browser.name in {
        go to ("http://localhost:" + port + "/testing")
        pageTitle mustBe "Test Page"
        click on find(name("b")).value
        eventually { pageTitle mustBe "scalatest" }
      }
    }
  }

  // Place tests you want run just once outside the `sharedTests` method
  // in the constructor, the usual place for tests in a `PlaySpec`
  "The AllBrowsersPerTest trait" must {
    "provide a FakeApplication" in {
      app.configuration.getOptional[String]("foo") mustBe Some("bar")
    }
    "make the FakeApplication available implicitly" in {
       def getConfig(key: String)(implicit app: Application) = app.configuration.getOptional[String](key)
      getConfig("foo") mustBe Some("bar")
    }
    "provide an http endpoint" in {
      runningServer.endpoints.httpEndpoint must not be empty
    }
    "provide an actual running server" in {
      import java.net._
      val url = new URL("http://localhost:" + port + "/boum")
      val con = url.openConnection().asInstanceOf[HttpURLConnection]
      try con.getResponseCode mustBe 404
      finally con.disconnect()
    }
  }
}

Here's how the output would look if you ran the above test class in sbt on a platform that did not support Selenium drivers for Internet Explorer or Chrome:

> test-only *allbrowserspersharedtest*
[info] ExampleSpec:
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [Firefox]
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [Safari]
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [InternetExplorer] !!! CANCELED !!!
[info]   Was unable to create a Selenium InternetExplorerDriver on this platform. (AllBrowsersPerTest.scala:257)
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [Chrome] !!! CANCELED !!!
[info]   Was unable to create a Selenium ChromeDriver on this platform. (AllBrowsersPerTest.scala:257)
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [HtmlUnit]
[info] The AllBrowsersPerTest trait
[info] - must provide a Application
[info] - must make the Application available implicitly
[info] - must start the Application
[info] - must provide the port
[info] - must provide an actual running server

Because the shared tests will be tagged according to browser, you can include or exclude tests based on the browser they use. For example, here's how the output would look if you ran the above test class with sbt and ask to include only Firefox:

> test-only *allbrowserspersharedtest* -- -n org.scalatest.tags.FirefoxBrowser
[info] ExampleSpec:
[info] The AllBrowsersPerTest trait
[info] - must provide a web driver [Firefox]
[info] The AllBrowsersPerTest trait
[info] The AllBrowsersPerTest trait
[info] The AllBrowsersPerTest trait
[info] The AllBrowsersPerTest trait
[info] The AllBrowsersPerTest trait