org.scalatest

trait BeforeAndAfterAll

[source: org/scalatest/BeforeAndAfterAll.scala]

trait BeforeAndAfterAll
extends AbstractSuite with AnyRef
Trait that can be mixed into suites that need methods invoked before and after executing the suite. This trait allows code to be executed before and/or after all the tests and nested suites of a suite are run. This trait overrides run (the main run method that takes seven parameters, an optional test name, reporter, stopper, filter, configMap, optional distributor, and tracker) and calls the beforeAll method, then calls super.run. After the super.run invocation completes, whether it returns normally or completes abruptly with an exception, this trait's run method will invoke afterAll.

Trait BeforeAndAfterEach defines two overloaded variants each of beforeAll and afterAll, one which takes a configMap and another that takes no arguments. This traits implemention of the variant that takes the configMap simply invokes the variant that takes no parameters, which does nothing. Thus you can override whichever variant you want. If you need something from the configMap before all tests and nested suites are run, override beforeAll(Map[String, Any]). Otherwise, override beforeAll().

For example, the following MasterSuite mixes in BeforeAndAfterAll and in beforeAll, creates and writes to a temp file, taking the name of the temp file from the configMap. This same configMap is then passed to the run methods of the nested suites, OneSuite, TwoSuite, RedSuite, and BlueSuite, so those suites can access the filename and, therefore, the file's contents. After all of the nested suites have executed, afterAll is invoked, which again grabs the file name from the configMap and deletes the file:

 import org.scalatest.SuperSuite
 import org.scalatest.BeforeAndAfterEach
 import java.io.FileReader
 import java.io.FileWriter
 import java.io.File

 class MasterSuite extends Suite with BeforeAndAfterAll {

   private val FileNameKeyInGoodies = "tempFileName"

   // Set up the temp file needed by the test, taking
   // a file name from the configMap
   override def beforeAll(configMap: Map[String, Any]) {

     require(
       configMap.isDefinedAt(FileNameKeyInGoodies),
       "must place a temp file name in the configMap under the key: " + FileNameKeyInGoodies
     )

     val fileName = configMap(tempFileName))

     val writer = new FileWriter(fileName)
     try {
       writer.write("Hello, suite of tests!")
     }
     finally {
       writer.close()
     }
   }

   override def nestedSuites =
     List(new OneSuite, new TwoSuite, new RedSuite, new BlueSuite)
 
   // Delete the temp file
   override def afterAll(configMap: Map[String, Any]) {
     // No need to require that configMap contains the key again because it won't get
     // here if it didn't contain the key in beforeAll 
     val fileName = configMap(tempFileName))
     val file = new File(fileName)
     file.delete()
   }
 }
 

Because the BeforeAndAfterAll trait invokes super.run to run the suite, you may need to mix this trait in last to get the desired behavior. For example, this won't work, because BeforeAndAfterAll is "super" to FunSuite:

 class MySuite extends BeforeAndAfterAll with FunSuite
 

You'd need to turn it around, so that FunSuite is "super" to BeforeAndAfterAll, like this:

 class MySuite extends FunSuite with BeforeAndAfterAll
 
Note: This trait does not currently ensure that the code in afterAll is executed after all the tests and nested suites are executed if a Distributor is passed. The plan is to do that eventually, but in the meantime, be aware that afterAll is guaranteed to be run after all the tests and nested suites only when they are run sequentially.
Author
Bill Venners
Direct Known Subclasses:
BeforeAndAfter

Method Summary
protected def afterAll (configMap : scala.collection.immutable.Map[java.lang.String, Any]) : Unit
Defines a method (that takes a configMap) to be run after all of this suite's tests and nested suites have been run.
protected def afterAll : Unit
Defines a method to be run after all of this suite's tests and nested suites have been run.
protected def beforeAll : Unit
Defines a method to be run before any of this suite's tests or nested suites are run.
protected def beforeAll (configMap : scala.collection.immutable.Map[java.lang.String, Any]) : Unit
Defines a method (that takes a configMap) to be run before any of this suite's tests or nested suites are run.
def run (testName : scala.Option[java.lang.String], reporter : Reporter, stopper : Stopper, filter : Filter, configMap : scala.collection.immutable.Map[java.lang.String, Any], distributor : scala.Option[Distributor], tracker : Tracker) : Unit
Execute a suite surrounded by calls to beforeAll and afterAll.
Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized
Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf
Methods inherited from AbstractSuite
withFixture (abstract), runNestedSuites (abstract), runTests (abstract), runTest (abstract), testNames (abstract), nestedSuites (abstract), tags (abstract), expectedTestCount (abstract)
Method Details
protected def beforeAll : Unit
Defines a method to be run before any of this suite's tests or nested suites are run.

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


protected def beforeAll(configMap : scala.collection.immutable.Map[java.lang.String, Any]) : Unit
Defines a method (that takes a configMap) to be run before any of this suite's tests or nested suites are run.

This trait's implementation of run invokes this method before executing any tests or nested suites (passing in the configMap passed to it), thus this method can be used to set up a test fixture needed by the entire suite. This trait's implementation of this method invokes the overloaded form of beforeAll that takes no configMap.


protected def afterAll : Unit
Defines a method to be run after all of this suite's tests and nested suites have been run.

This trait's implementation of run invokes the overloaded form of this method that takes a configMap after executing all tests and nested suites. This trait's implementation of that afterAll(Map[String, Any]) method simply invokes this afterAll() method. Thus this method can be used to tear down a test fixture needed by the entire suite, when you don't need anything from the configMap. This trait's implementation of this method does nothing.


protected def afterAll(configMap : scala.collection.immutable.Map[java.lang.String, Any]) : Unit
Defines a method (that takes a configMap) to be run after all of this suite's tests and nested suites have been run.

This trait's implementation of run invokes this method after executing all tests and nested suites (passing in the configMap passed to it), thus this method can be used to tear down a test fixture needed by the entire suite. This trait's implementation of this method invokes the overloaded form of afterAll that takes no configMap.


def run(testName : scala.Option[java.lang.String], reporter : Reporter, stopper : Stopper, filter : Filter, configMap : scala.collection.immutable.Map[java.lang.String, Any], distributor : scala.Option[Distributor], tracker : Tracker) : Unit
Execute a suite surrounded by calls to beforeAll and afterAll.

This trait's implementation of this method ("this method") invokes beforeAll(Map[String, Any]) before executing any tests or nested suites and afterAll(Map[String, Any]) after executing all tests and nested suites. It runs the suite by invoking super.run, passing along the seven parameters passed to it.

If any invocation of beforeAll completes abruptly with an exception, this method will complete abruptly with the same exception. If any call to super.run completes abruptly with an exception, this method will complete abruptly with the same exception, however, before doing so, it will invoke afterAll. If afterAll also completes abruptly with an exception, this method will nevertheless complete abruptly with the exception previously thrown by super.run. If super.run returns normally, but afterAll completes abruptly with an exception, this method will complete abruptly with the same exception.

Overrides
AbstractSuite.run


Copyright (C) 2001-2010 Artima, Inc. All rights reserved.