org.scalatest.BeforeAndAfterEach

Stackable trait that can be mixed into suites that need code executed before and after running each test.

Recommended Usage: Use trait BeforeAndAfterEach when you want to stack traits that perform side-effects before and/or after tests, rather than at the beginning or end of tests, or when you need access to the config map or test name in the before and/or after code. Note: For more insight into where BeforeAndAfterEach fits into the big picture, see the Shared fixtures section in the documentation for your chosen style trait.

A test fixture is composed of the objects and other artifacts (files, sockets, database connections, etc.) tests use to do their work. When multiple tests need to work with the same fixtures, it is important to try and avoid duplicating the fixture code across those tests. The more code duplication you have in your tests, the greater drag the tests will have on refactoring the actual production code. Trait BeforeAndAfterEach offers one way to eliminate such code duplication: a beforeEach method that will be run before each test (like JUnit's setUp), and an afterEach method that will be run after (like JUnit's tearDown).

Here's an example:

package org.scalatest.examples.flatspec.composingbeforeandaftereach

import org.scalatest._
import collection.mutable.ListBuffer

trait Builder extends BeforeAndAfterEach { this: Suite =>

  val builder = new StringBuilder

  override def beforeEach() {
    builder.append("ScalaTest is ")
    super.beforeEach() // To be stackable, must call super.beforeEach
  }

  override def afterEach() {
    try {
      super.afterEach() // To be stackable, must call super.afterEach
    }
    finally {
      builder.clear()
    }
  }
}

trait Buffer extends BeforeAndAfterEach { this: Suite =>

  val buffer = new ListBuffer[String]

  override def afterEach() {
    try {
      super.afterEach() // To be stackable, must call super.afterEach
    }
    finally {
      buffer.clear()
    }
  }
}

class ExampleSpec extends FlatSpec with Builder with Buffer {

  "Testing" should "be easy" in {
    builder.append("easy!")
    assert(builder.toString === "ScalaTest is easy!")
    assert(buffer.isEmpty)
    buffer += "sweet"
  }

  it should "be fun" in {
    builder.append("fun!")
    assert(builder.toString === "ScalaTest is fun!")
    assert(buffer.isEmpty)
    buffer += "clear"
  }
}

To get the same ordering as withFixture, place your super.beforeEach call at the end of each beforeEach method, and the super.afterEach call at the beginning of each afterEach method, as shown in the previous example. It is a good idea to invoke super.afterEach in a try block and perform cleanup in a finally clause, as shown in the previous example, because this ensures the cleanup code is performed even if super.afterEach throws an exception.

Besides enabling trait stacking, the other main advantage of BeforeAndAfterEach over BeforeAndAfter is that BeforeAndAfterEach allows you to make use of test data (the test name and the config map) in your before and/or after code, whereas BeforeAndAfter does not. To access the test data, simply override the form of beforeEach and/or afterEach that takes a TestData parameter, like this.

override def beforeEach(td: TestData) {
  // Can now use the test data in your "before" code:
  //   td.name is the name of the test
  //   td.configMap is the config map passed to runTest
}

override def afterEach(td: TestData) {
  // Can now use the test data in your "after" code:
  //   td.name is the name of the test
  //   td.configMap is the config map passed to runTest
}

The main disadvantage of BeforeAndAfterEach compared to BeforeAndAfter is that BeforeAndAfterEach requires more boilerplate. If you don't need trait stacking or access to the test data, use BeforeAndAfter instead of BeforeAndAfterEach.

Self Type: BeforeAndAfterEach with Suite

Linear Supertypes

SuiteMixin, AnyRef, Any

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

BeforeAndAfterEach
SuiteMixin
AnyRef
Any

Visibility

Public
All

Abstract Value Members

def expectedTestCount (filter: Filter): Int

The total number of tests that are expected to run when this Suite's run method is invoked.
The total number of tests that are expected to run when this Suite's run method is invoked.
filter
a Filter with which to filter tests to count based on their tags

Attributes
abstract
Definition Classes
SuiteMixin
def nestedSuites : IndexedSeq[Suite]

An immutable IndexedSeq of this SuiteMixin object's nested Suites.
An immutable IndexedSeq of this SuiteMixin object's nested Suites. If this SuiteMixin contains no nested Suites, this method returns an empty IndexedSeq.

Attributes
abstract
Definition Classes
SuiteMixin
def rerunner : Option[String]

The fully qualified name of the class that can be used to rerun this suite.
The fully qualified name of the class that can be used to rerun this suite.

Attributes
abstract
Definition Classes
SuiteMixin
def run (testName: Option[String], args: Args): Status

Runs this suite of tests.
Runs this suite of tests.
testName
an optional name of one test to execute. If None, all relevant tests should be executed. I.e., None acts like a wildcard that means execute all relevant tests in this Suite.
args
the Args for this run
returns
a Status object that indicates when all tests and nested suites started by this method have completed, and whether or not a failure occurred.

Attributes
abstract
Definition Classes
SuiteMixin
def runNestedSuites (args: Args): Status

Runs zero to many of this suite's nested suites.
Runs zero to many of this suite's nested suites.
args
the Args for this run
returns
a Status object that indicates when all nested suites started by this method have completed, and whether or not a failure occurred.

Attributes
protected abstract
Definition Classes
SuiteMixin
def runTests (testName: Option[String], args: Args): Status

Runs zero to many of this suite's tests.
Runs zero to many of this suite's tests.
testName
an optional name of one test to run. If None, all relevant tests should be run. I.e., None acts like a wildcard that means run all relevant tests in this Suite.
args
the Args for this run
returns
a Status object that indicates when all tests started by this method have completed, and whether or not a failure occurred.

Attributes
protected abstract
Definition Classes
SuiteMixin
val styleName : String

This suite's style name.
This suite's style name.
This lifecycle method provides a string that is used to determine whether this suite object's style is one of the chosen styles for the project.

Attributes
abstract
Definition Classes
SuiteMixin
def tags : Map[String, Set[String]]

A Map whose keys are String tag names with which tests in this Suite are marked, and whose values are the Set of test names marked with each tag.
A Map whose keys are String tag names with which tests in this Suite are marked, and whose values are the Set of test names marked with each tag. If this Suite contains no tags, this method returns an empty Map.
Subclasses may implement this method to define and/or discover tags in a custom manner, but overriding method implementations should never return an empty Set as a value. If a tag has no tests, its name should not appear as a key in the returned Map.

Attributes
abstract
Definition Classes
SuiteMixin
def testNames : Set[String]

A Set of test names.
A Set of test names. If this Suite contains no tests, this method returns an empty Set.
Although subclass and subtrait implementations of this method may return a Set whose iterator produces String test names in a well-defined order, the contract of this method does not required a defined order. Subclasses are free to implement this method and return test names in either a defined or undefined order.

Attributes
abstract
Definition Classes
SuiteMixin
def withFixture (test: NoArgTest): Unit

Runs the passed test function with a fixture established by this method.
Runs the passed test function with a fixture established by this method.
This method should set up the fixture needed by the tests of the current suite, invoke the test function, and if needed, perform any clean up needed after the test completes. Because the NoArgTest function passed to this method takes no parameters, preparing the fixture will require side effects, such as initializing an external database.
test
the no-arg test function to run with a fixture

Attributes
protected abstract
Definition Classes
SuiteMixin

Concrete Value Members

def != (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def != (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def ## (): Int

Attributes
final
Definition Classes
AnyRef → Any
def == (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def == (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def afterEach (testData: TestData): Unit

Defines a method (that takes a TestData) to be run after each of this suite's tests.
Defines a method (that takes a TestData) to be run after each of this suite's tests.
This trait's implementation of runTest invokes this method after running each test (passing in a TestData containing the configMap passed to it), thus this method can be used to tear down a test fixture needed by each test. This trait's implementation of this method invokes the overloaded form of afterEach that takes configMap. After the deprecation cycle, this method will invoke the no-arg form of afterEach.

Attributes
protected
def afterEach (): Unit

Defines a method to be run after each of this suite's tests.
Defines a method to be run after each of this suite's tests.
This trait's implementation of runTest invokes the overloaded form of this method that takes a configMap map after running each test. This trait's implementation of that afterEach(Map[String, Any]) method simply invokes this afterEach() method. Thus this method can be used to tear down a test fixture needed by each test, when you don't need anything from the configMap. This trait's implementation of this method does nothing.

Attributes
protected
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
def beforeEach (testData: TestData): Unit

Defines a method (that takes a TestData) to be run before each of this suite's tests.
Defines a method (that takes a TestData) to be run before each of this suite's tests.
This trait's implementation of runTest invokes this method before running each test (passing in the configMap passed to it), thus this method can be used to set up a test fixture needed by each test. This trait's implementation of this method invokes the overloaded form of beforeEach that takes configMap. After the deprecation cycle, this method will invoke the no-arg form of beforeEach.

Attributes
protected
def beforeEach (): Unit

Defines a method to be run before each of this suite's tests.
Defines a method to be run before each of this suite's tests.
This trait's implementation of runTest invokes the overloaded form of this method that takes a configMap before running each test. This trait's implementation of that beforeEach(Map[String, Any]) method simply invokes this beforeEach() method. Thus this method can be used to set up a test fixture needed by each test, when you don't need anything from the configMap. This trait's implementation of this method does nothing.

Attributes
protected
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equals (arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef
def hashCode (): Int

Definition Classes
AnyRef → Any
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
def ne (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

Attributes
final
Definition Classes
AnyRef
def runTest (testName: String, args: Args): Status

Run a test surrounded by calls to beforeEach and afterEach.
Run a test surrounded by calls to beforeEach and afterEach.
This trait's implementation of this method ("this method") invokes beforeEach(configMap) before running each test and afterEach(configMap) after running each test. It runs each test by invoking super.runTest, passing along the two parameters passed to it.
If any invocation of beforeEach completes abruptly with an exception, this method will complete abruptly with the same exception. If any call to super.runTest completes abruptly with an exception, this method will complete abruptly with the same exception, however, before doing so, it will invoke afterEach. If <cod>afterEach also completes abruptly with an exception, this method will nevertheless complete abruptly with the exception previously thrown by super.runTest. If super.runTest returns normally, but afterEach completes abruptly with an exception, this method will complete abruptly with the exception thrown by afterEach.
testName
the name of one test to run.
args
the Args for this run
returns
a Status object that indicates when the test started by this method has completed, and whether or not it failed .

Attributes
protected
Definition Classes
BeforeAndAfterEach → SuiteMixin
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def toString (): String

Definition Classes
AnyRef → Any
def wait (): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long, arg1: Int): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def afterEach (configMap: Map[String, Any]): Unit

This overloaded form of afterEach has been deprecated and will be removed in a future version of ScalaTest. Please use afterEach(TestData) instead.
This overloaded form of afterEach has been deprecated and will be removed in a future version of ScalaTest. Please use afterEach(TestData) instead.
During the deprecation cycle, this trait's implementation of afterEach(TestData) invokes will this method. This trait's implementation of this method invokes the overloaded form of afterEach that takes no configMap.

Attributes
protected
Annotations
@deprecated
Deprecated
Please use afterEach(TestData) instead.
def beforeEach (configMap: Map[String, Any]): Unit

This overloaded form of beforeEach has been deprecated and will be removed in a future version of ScalaTest. Please use beforeEach(TestData) instead.
This overloaded form of beforeEach has been deprecated and will be removed in a future version of ScalaTest. Please use beforeEach(TestData) instead.
During the deprecation cycle, this trait's implementation of beforeEach(TestData) invokes will this method. This trait's implementation of this method invokes the overloaded form of beforeEach that takes no configMap.

Attributes
protected
Annotations
@deprecated
Deprecated
Please use beforeEach(TestData) instead.

BeforeAndAfterEach

trait BeforeAndAfterEach extends SuiteMixin

Abstract Value Members

def expectedTestCount (filter: Filter): Int

def nestedSuites : IndexedSeq[Suite]

def rerunner : Option[String]

def run (testName: Option[String], args: Args): Status

def runNestedSuites (args: Args): Status

def runTests (testName: Option[String], args: Args): Status

val styleName : String

def tags : Map[String, Set[String]]

def testNames : Set[String]

def withFixture (test: NoArgTest): Unit

Concrete Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def afterEach (testData: TestData): Unit

def afterEach (): Unit

def asInstanceOf [T0] : T0

def beforeEach (testData: TestData): Unit

def beforeEach (): Unit

def clone (): AnyRef

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def runTest (testName: String, args: Args): Status

def synchronized [T0] (arg0: ⇒ T0): T0

def toString (): String

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def afterEach (configMap: Map[String, Any]): Unit

def beforeEach (configMap: Map[String, Any]): Unit

Inherited from SuiteMixin

Inherited from AnyRef

Inherited from Any