org.scalatest.concurrent.AbstractPatienceConfiguration.scala Maven / Gradle / Ivy

/*
 * Copyright 2001-2013 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalatest.concurrent

import org.scalatest.time.{Span, Millis}


/**
 * Trait that defines an abstract patienceConfig method that is implemented in PatienceConfiguration and can
 * be overriden in stackable modification traits such as IntegrationPatience.
 *
 * 
 * The main purpose of AbstractPatienceConfiguration is to differentiate core PatienceConfiguration
 * traits, such as Eventually and Waiters, from stackable
 * modification traits for PatienceConfigurations such as IntegrationPatience.
 * Because these stackable traits extend AbstractPatienceConfiguration 
 * instead of Suite, you can't simply mix in a stackable trait:
 * 
 *
 *  * class ExampleSpec extends FunSpec with IntegrationPatience // Won't compile
 * 
 *
 * 
 * The previous code is undesirable because IntegrationPatience would have no affect on the class. Instead, you need to mix
 * in a core PatienceConfiguration trait and mix the stackable IntegrationPatience trait
 * into that, like this:
 * 
 *
 *  * class ExampleSpec extends FunSpec with Eventually with IntegrationPatience // Compiles fine
 * 
 *
 * 
 * The previous code is better because IntegrationPatience does have an effect: it modifies the behavior
 * of Eventually.
 * 
 *
 * @author Bill Venners
 */
trait AbstractPatienceConfiguration extends ScaledTimeSpans {

  /**
   * Configuration object for asynchronous constructs, such as those provided by traits Eventually and
   * Waiters.
   *
   * 
   * The default values for the parameters are:
   * 
   *
   * 
 * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * Configuration Parameter Default Value

   * timeout
   * 
   * scaled(150 milliseconds)
   * 

   * interval
   * 
   * scaled(15 milliseconds)
   * 
   *
   * @param timeout the maximum amount of time to wait for an asynchronous operation to complete before giving up and throwing
   *   TestFailedException.
   * @param interval the amount of time to sleep between each check of the status of an asynchronous operation when polling
   *
   * @author Bill Venners
   * @author Chua Chee Seng
   */
  final case class PatienceConfig(timeout: Span = scaled(Span(150, Millis)), interval: Span = scaled(Span(15, Millis)))

  /**
   * Returns a PatienceConfig value providing default configuration values if implemented and made implicit in subtraits.
   */
  def patienceConfig: PatienceConfig
}
Configuration Parameter	Default Value
* `timeout` *	* `scaled(150 milliseconds)` *
* `interval` *	* `scaled(15 milliseconds)` *