Packages

•  package root

  Definition Classes

  root

•  package org

  Definition Classes

  root

•  package scalatest

  ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

  ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

  Definition Classes

  org

•  trait FixtureAsyncTestSuite extends FixtureSuite with AsyncTestSuite

  The base trait of ScalaTest's "fixture" async testing styles, which enable you to pass fixture objects into tests.

  The base trait of ScalaTest's "fixture" async testing styles, which enable you to pass fixture objects into tests.

  This trait provides a final override of withFixture(OneArgTest), declared in supertrait FixtureSuite, because the withFixture(OneArgTest) lifecycle method assumes synchronous testing. Here is its signature:

  def withFixture(test: OneArgTest): Outcome
  

  The test function interface, OneArgTest, offers an apply method that takes a FixtureParam and returns Outcome:

  // In trait OneArgTest:
  def apply(fixture: FixtureParam): Outcome
  

  Because the result of a test is an Outcome, when the test function returns, the test body must have determined an outcome already. It will already be one of Succeeded, Failed, Canceled, or Pending. This is also true when withFixture(OneArgTest) returns: because the result type of withFixture(OneArgTest) is Outcome, the test body has by definition has already finished execution.

  This trait overrides and makes abstract the runTest method. Subtraits must must implement this method to call withFixture(OneArgAsyncTest) instead of withFixture(OneArgTest), where withFixture(OneArgAsyncTest) is a new method declared in this trait with the following signature and implementation:

  def withFixture(test: OneArgAsyncTest): FutureOutcome = {
    test()
  }
  

  Instead of returning Outcome like withFixture, the withFixture method returns a FutureOutcome. Similarly, the apply method of test function interface, OneArgAsyncTest, returns FutureOutcome:

  // In trait OneArgAsyncTest:
  def apply(fixture: FixtureParam): FutureOutcome
  

  The withFixture method supports async testing, because when the test function returns, the test body has not necessarily finished execution.

  The recommended way to ensure cleanup is performed after a test body finishes execution is to use the complete-lastly syntax, defined in supertrait org.scalatest.CompleteLastly, which will ensure that cleanup will occur whether future-producing code completes abruptly by throwing an exception, or returns normally yielding a future. In the latter case, complete-lastly will register the cleanup code to execute asynchronously when the future completes.

  To enable the stacking of traits that define withFixture(NoArgAsyncTest), it is a good idea to let withFixture(NoArgAsyncTest) invoke the test function instead of invoking the test function directly. To do so, you'll need to convert the OneArgAsyncTest to a NoArgAsyncTest. You can do that by passing the fixture object to the toNoArgAsyncTest method of OneArgAsyncTest. In other words, instead of writing “test(theFixture)”, you'd delegate responsibility for invoking the test function to the withFixture(NoArgAsyncTest) method of the same instance by writing:

  withFixture(test.toNoArgAsyncTest(theFixture))
  

  Thus, the recommended structure of a withFixture implementation that performs cleanup looks like this:

  // Your implementation
  override def withFixture(test: OneArgAsyncTest) = {
  
    // Perform setup here
    val theFixture = ...
  
    complete {
      withFixture(test.toNoArgAsyncTest(theFixture)) // Invoke the test function
    } lastly {
      // Perform cleanup here
    }
  }
  

  If you have no cleanup to perform, you can write withFixture like this instead:

  // Your implementation
  override def withFixture(test: OneArgAsyncTest) = {
  
    // Perform setup here
    val theFixture = ...
  
    withFixture(test.toNoArgAsyncTest(theFixture)) // Invoke the test function
  }
  

  If you want to perform an action only for certain outcomes, you'll need to register code performing that action as a callback on the Future using one of Future registration methods: onComplete, onSuccess, or onFailure. Note that if a test fails, that will be treated as a scala.util.Success(org.scalatest.Failure). So if you want to perform an action if a test fails, for example, you'd register the callaback using onSuccess, like this:

  // Your implementation
  override def withFixture(test: OneArgAsyncTest) = {
  
    // Perform setup here
    val theFixture = ...
  
    val futureOutcome =
        withFixture(test.toNoArgAsyncTest(theFixture)) // Invoke the test function
  
    futureOutcome onFailedThen { _ =>
      // perform action that you want to occur
      // only if a test fails here
    }
  }
  

  Lastly, if you want to transform the outcome in some way in withFixture, you'll need to use either the map or transform methods of Future, like this:

  // Your implementation
  override def withFixture(test: OneArgAsyncTest) = {
  
    // Perform setup here
    val theFixture = ...
  
    val futureOutcome =
        withFixture(test.toNoArgAsyncTest(theFixture)) // Invoke the test function
  
    futureOutcome change { outcome =>
      // transform the outcome into a new outcome here
    }
  }
  

  Note that a NoArgAsyncTest's apply method will only return a Failure if the test completes abruptly with an exception (such as OutOfMemoryError) that should cause the suite to abort rather than the test to fail. Thus usually you would use map to transform future outcomes, not transform, so that such suite-aborting exceptions pass through unchanged. The suite will abort asynchronously with any exception returned in a Failure.

  Definition Classes

  scalatest

• CheckingEqualizer
• Equalizer
• FixtureParam
• NoArgAsyncTest
• OneArgAsyncTest
• ResultOfCompleteInvocation

org.scalatest.FixtureAsyncTestSuite

OneArgAsyncTest