ScaledTimeSpans
Trait providing a scaled
method that can be used to scale time Span
s used during the testing of asynchronous operations.
The scaled
method allows tests of asynchronous operations to be tuned according to need. For example, Span
s can be scaled larger when running tests on slower continuous integration servers or smaller when running on faster development machines.
The Double
factor by which to scale the Span
s passed to scaled
is obtained from the spanScaleFactor
method, also declared in this trait. By default this method returns 1.0, but can be configured to return a different value by passing a -F
argument to Runner
(or an equivalent mechanism in an ant, sbt, or Maven build file).
The default timeouts and intervals defined for traits Eventually
and Waiters
invoke scaled
, so those defaults will be scaled automatically. Other than such defaults, however, to get a Span
to scale you'll need to explicitly pass it to scaled
. For example, here's how you would scale a Span
you supply to the failAfter
method from trait Timeouts
:
failAfter(scaled(150 millis)) { // ... }
The reason Span
s are not scaled automatically in the general case is to make code obvious. If a reader sees failAfter(1 second)
, it will mean exactly that: fail after one second. And if a Span
will be scaled, the reader will clearly see that as well: failAfter(scaled(1 second))
.
== Overriding spanScaleFactor
==
You can override the spanScaleFactor
method to configure the factor by a different means. For example, to configure the factor from Akka TestKit's test time factor you might create a trait like this:
import org.scalatest.concurrent.ScaledTimeSpans import akka.actor.ActorSystem import akka.testkit.TestKitExtension trait AkkaSpanScaleFactor extends ScaledTimeSpans { override def spanScaleFactor: Double = TestKitExtension.get(ActorSystem()).TestTimeFactor }
This trait overrides spanScaleFactor
so that it takes its scale factor from Akka's application.conf
file. You could then scale Span
s tenfold in Akka's configuration file like this:
akka { test { timefactor = 10.0 } }
Armed with this trait and configuration file, you can simply mix trait AkkaSpanScaleFactor
into any test class whose Span
s you want to scale, like this:
class MySpec extends FunSpec with Eventually with AkkaSpanScaleFactor { // .. }
Attributes
- Graph
-
- Supertypes
-
class Objecttrait Matchableclass Any
- Known subtypes
-
trait IntegrationPatiencetrait PatienceConfigurationtrait Conductorstrait ConductorMethodstrait Eventuallyobject Eventually.typetrait Futuresobject Futures.typetrait JavaFuturestrait ScalaFuturesobject ScalaFutures.typetrait Waitersobject Waiters.type