Type Members

1.  abstract class AbstractRunnableSpec extends AnyRef

   Annotations

   @EnableReflectiveInstantiation()

2.  type Annotated[+A] = (A, TestAnnotationMap)

   An Annotated[A] contains a value of type A along with zero or more test annotations.

3.  trait Annotations extends Serializable

   The Annotations trait provides access to an annotation map that tests can add arbitrary annotations to.

   The Annotations trait provides access to an annotation map that tests can add arbitrary annotations to. Each annotation consists of a string identifier, an initial value, and a function for combining two values. Annotations form monoids and you can think of Annotations as a more structured logging service or as a super polymorphic version of the writer monad effect.

4.  case class Assert(arrow: TestArrow[Any, Boolean]) extends Product with Serializable
5.  type AssertResult = BoolAlgebra[AssertionValue]
6.  type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
7.  final class Assertion[-A] extends AssertionM[A] with (⇒ A) ⇒ AssertResult

   An Assertion[A] is capable of producing assertion results on an A.

   An Assertion[A] is capable of producing assertion results on an A. As a proposition, assertions compose using logical conjunction and disjunction, and can be negated.

8.  sealed abstract class AssertionData extends AnyRef
9.  abstract class AssertionM[-A] extends AnyRef

   An AssertionM[A] is capable of producing assertion results on an A.

   An AssertionM[A] is capable of producing assertion results on an A. As a proposition, assertions compose using logical conjunction and disjunction, and can be negated.

10.  sealed abstract class AssertionMData extends AnyRef
11.  sealed trait AssertionResult extends AnyRef
12.  sealed abstract class AssertionValue extends AnyRef

    An AssertionValue keeps track of a assertion and a value, existentially hiding the type.

    An AssertionValue keeps track of a assertion and a value, existentially hiding the type. This is used internally by the library to provide useful error messages in the event of test failures.

13.  trait AssertionVariants extends AnyRef
14.  sealed abstract class BoolAlgebra[+A] extends Product with Serializable

    A BoolAlgebra[A] is a description of logical operations on values of type A.

15.  final case class BoolAlgebraM[-R, +E, +A](run: ZIO[R, E, BoolAlgebra[A]]) extends Product with Serializable
16.  trait CheckConstructor[Environment, In] extends AnyRef
17.  trait CheckConstructorLowPriority1 extends CheckConstructorLowPriority2
18.  trait CheckConstructorLowPriority2 extends CheckConstructorLowPriority3
19.  trait CheckConstructorLowPriority3 extends CheckConstructorLowPriority4
20.  trait CheckConstructorLowPriority4 extends CheckConstructorLowPriority5
21.  trait CheckConstructorLowPriority5 extends AnyRef
22.  trait CompileVariants extends AnyRef
23.  final class CustomAssertion[A, B] extends AnyRef

    CustomAssertion allows users to create their own custom assertions for use in assertTrue.

    CustomAssertion allows users to create their own custom assertions for use in assertTrue. They are constructed with CustomAssertion.make.

    // Definition
    sealed trait Pet
    case class Dog(hasBone: Boolean) extends Pet
    case class Fish(bubbles: Double) extends Pet
    case class Cat(livesRemaining: Int) extends Color
    
    val lives =
      CustomAssertion.make[Pet] {
        case Cat(livesRemaining) => Right(livesRemaining)
        case other => Left(s"Expected $$other to be Cat")
      }
    
    // Usage
    suite("custom assertions")(
      test("as even") {
        val pet: Option[Pet] = Some(Cat(8))
        assertTrue(pet.is(_.some.custom(lives)) == 8)
      }
    )

24.  abstract class DefaultRunnableSpec extends RunnableSpec[TestEnvironment, Any]

    A default runnable spec that provides testable versions of all of the modules in ZIO (Clock, Random, etc).

25.  sealed abstract class Eql[A, B] extends AnyRef

    A value of type Eql[A, B] provides implicit evidence that two values with types A and B could potentially be equal, that is, that A is a subtype of B or B is a subtype of A.

    A value of type Eql[A, B] provides implicit evidence that two values with types A and B could potentially be equal, that is, that A is a subtype of B or B is a subtype of A.

    Annotations

    @implicitNotFound( ... )

26.  sealed trait ErrorMessage extends AnyRef
27.  final case class ExecutedSpec[+E](caseValue: SpecCase[E, ExecutedSpec[E]]) extends Product with Serializable

    An ExecutedSpec is a spec that has been run to produce test results.

28.  case class FailureCase(errorMessage: Message, codeString: String, location: String, path: Chunk[(String, Any)], span: Span, nestedFailures: Chunk[FailureCase], result: Any) extends Product with Serializable
29.  final case class FailureDetails(assertion: ::[AssertionValue]) extends Product with Serializable

    FailureDetails keeps track of details relevant to failures.

30.  trait FunctionVariants extends AnyRef
31.  final case class Gen[-R, +A](sample: ZStream[R, Nothing, Option[Sample[R, A]]]) extends Product with Serializable

    A Gen[R, A] represents a generator of values of type A, which requires an environment R.

    A Gen[R, A] represents a generator of values of type A, which requires an environment R. Generators may be random or deterministic.

32.  sealed abstract class GenFailureDetails extends AnyRef

    GenFailureDetails keeps track of relevant information related to a failure in a generative test.

33.  trait GenZIO extends AnyRef
34.  trait Live extends AnyRef

    The Live trait provides access to the "live" environment from within the test environment for effects such as printing test results to the console or timing out tests where it is necessary to access the real environment.

    The Live trait provides access to the "live" environment from within the test environment for effects such as printing test results to the console or timing out tests where it is necessary to access the real environment.

    The easiest way to access the "live" environment is to use the live method with an effect that would otherwise access the test environment.

    import zio.Clock
    import zio.test._
    
    val realTime = live(Clock.nanoTime)

    The withLive method can be used to apply a transformation to an effect with the live environment while ensuring that the effect itself still runs with the test environment, for example to time out a test. Both of these methods are re-exported in the environment package for easy availability.

35.  trait PrettyPrintVersionSpecific extends AnyRef
36.  trait Restorable extends Serializable
37.  sealed trait Result[+A] extends AnyRef
38.  abstract class RunnableSpec[R, E] extends AbstractRunnableSpec

    A RunnableSpec has a main function and can be run by the JVM / Scala.js.

39.  final case class Sample[-R, +A](value: A, shrink: ZStream[R, Nothing, Option[Sample[R, A]]]) extends Product with Serializable

    A sample is a single observation from a random variable, together with a tree of "shrinkings" used for minimization of "large" failures.

40.  trait Sized extends Serializable
41.  class SmartAssertMacros extends AnyRef
42.  implicit final class SmartAssertionOps[A] extends AnyVal
43.  final case class Spec[-R, +E, +T](caseValue: SpecCase[R, E, T, Spec[R, E, T]]) extends SpecVersionSpecific[R, E, T] with Product with Serializable

    A Spec[R, E, T] is the backbone of _ZIO Test_.

    A Spec[R, E, T] is the backbone of _ZIO Test_. Every spec is either a suite, which contains other specs, or a test of type T. All specs require an environment of type R and may potentially fail with an error of type E.

44.  class SpecLayerMacros extends LayerMacroUtils
45.  trait SuiteConstructor[In] extends AnyRef
46.  trait SuiteConstructorLowPriority1 extends SuiteConstructorLowPriority2
47.  trait SuiteConstructorLowPriority2 extends SuiteConstructorLowPriority3
48.  trait SuiteConstructorLowPriority3 extends SuiteConstructorLowPriority4
49.  trait SuiteConstructorLowPriority4 extends AnyRef
50.  final case class Summary(success: Int, fail: Int, ignore: Int, summary: String) extends Product with Serializable
51.  final class TestAnnotation[V] extends Serializable

    A type of annotation.

52.  final class TestAnnotationMap extends AnyRef

    An annotation map keeps track of annotations of different types.

53.  sealed abstract class TestAnnotationRenderer extends AnyRef

    A TestAnnotationRenderer knows how to render test annotations.

54.  final case class TestArgs(testSearchTerms: List[String], tagSearchTerms: List[String], testTaskPolicy: Option[String], testRenderer: Option[String], printSummary: Boolean) extends Product with Serializable
55.  sealed trait TestArrow[-A, +B] extends AnyRef
56.  abstract class TestAspect[+LowerR, -UpperR, +LowerE, -UpperE] extends AnyRef

    A TestAspect is an aspect that can be weaved into specs.

    A TestAspect is an aspect that can be weaved into specs. You can think of an aspect as a polymorphic function, capable of transforming one test into another, possibly enlarging the environment or error type.

57.  type TestAspectAtLeastR[-R] = TestAspect[Nothing, R, Nothing, Any]

    A TestAspectAtLeast[R] is a TestAspect that requires at least an R in its environment.

58.  type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]

    A TestAspectPoly is a TestAspect that is completely polymorphic, having no requirements on error or environment.

59.  trait TestClock extends Clock with Restorable

    TestClock makes it easy to deterministically and efficiently test effects involving the passage of time.

    TestClock makes it easy to deterministically and efficiently test effects involving the passage of time.

    Instead of waiting for actual time to pass, sleep and methods implemented in terms of it schedule effects to take place at a given clock time. Users can adjust the clock time using the adjust and setTime methods, and all effects scheduled to take place on or before that time will automatically be run in order.

    For example, here is how we can test ZIO#timeout using TestClock:

    import zio.ZIO
    import zio.test.TestClock
    
    for {
      fiber  <- ZIO.sleep(5.minutes).timeout(1.minute).fork
      _      <- TestClock.adjust(1.minute)
      result <- fiber.join
    } yield result == None

    Note how we forked the fiber that sleep was invoked on. Calls to sleep and methods derived from it will semantically block until the time is set to on or after the time they are scheduled to run. If we didn't fork the fiber on which we called sleep we would never get to set the time on the line below. Thus, a useful pattern when using TestClock is to fork the effect being tested, then adjust the clock time, and finally verify that the expected effects have been performed.

    For example, here is how we can test an effect that recurs with a fixed delay:

    import zio.Queue
    import zio.test.TestClock
    
    for {
      q <- Queue.unbounded[Unit]
      _ <- q.offer(()).delay(60.minutes).forever.fork
      a <- q.poll.map(_.isEmpty)
      _ <- TestClock.adjust(60.minutes)
      b <- q.take.as(true)
      c <- q.poll.map(_.isEmpty)
      _ <- TestClock.adjust(60.minutes)
      d <- q.take.as(true)
      e <- q.poll.map(_.isEmpty)
    } yield a && b && c && d && e

    Here we verify that no effect is performed before the recurrence period, that an effect is performed after the recurrence period, and that the effect is performed exactly once. The key thing to note here is that after each recurrence the next recurrence is scheduled to occur at the appropriate time in the future, so when we adjust the clock by 60 minutes exactly one value is placed in the queue, and when we adjust the clock by another 60 minutes exactly one more value is placed in the queue.

60.  trait TestClockPlatformSpecific extends AnyRef
61.  trait TestConfig extends Serializable

    The TestConfig service provides access to default configuration settings used by ZIO Test, including the number of times to repeat tests to ensure they are stable, the number of times to retry flaky tests, the sufficient number of samples to check from a random variable, and the maximum number of shrinkings to minimize large failures.

62.  trait TestConsole extends Console with Restorable

    TestConsole provides a testable interface for programs interacting with the console by modeling input and output as reading from and writing to input and output buffers maintained by TestConsole and backed by a Ref.

    TestConsole provides a testable interface for programs interacting with the console by modeling input and output as reading from and writing to input and output buffers maintained by TestConsole and backed by a Ref.

    All calls to print and printLine using the TestConsole will write the string to the output buffer and all calls to readLine will take a string from the input buffer. To facilitate debugging, by default output will also be rendered to standard output. You can enable or disable this for a scope using debug, silent, or the corresponding test aspects.

    TestConsole has several methods to access and manipulate the content of these buffers including feedLines to feed strings to the input buffer that will then be returned by calls to readLine, output to get the content of the output buffer from calls to print and printLine, and clearInput and clearOutput to clear the respective buffers.

    Together, these functions make it easy to test programs interacting with the console.

    import zio.Console._
    import zio.test.TestConsole
    import zio.ZIO
    
    val sayHello = for {
      name <- readLine
      _    <- printLine("Hello, " + name + "!")
    } yield ()
    
    for {
      _ <- TestConsole.feedLines("John", "Jane", "Sally")
      _ <- ZIO.collectAll(List.fill(3)(sayHello))
      result <- TestConsole.output
    } yield result == Vector("Hello, John!\n", "Hello, Jane!\n", "Hello, Sally!\n")

63.  trait TestConstructor[-Environment, In] extends AnyRef
64.  trait TestConstructorLowPriority1 extends TestConstructorLowPriority2
65.  trait TestConstructorLowPriority2 extends TestConstructorLowPriority3
66.  trait TestConstructorLowPriority3 extends TestConstructorLowPriority4
67.  trait TestConstructorLowPriority4 extends TestConstructorLowPriority5
68.  trait TestConstructorLowPriority5 extends AnyRef
69.  sealed trait TestDuration extends AnyRef
70.  type TestEnvironment = Annotations with Live with Sized with TestClock with TestConfig with TestConsole with TestRandom with TestSystem
71.  abstract class TestExecutor[+R, E] extends AnyRef

    A TestExecutor[R, E] is capable of executing specs that require an environment R and may fail with an E.

72.  sealed abstract class TestFailure[+E] extends AnyRef
73.  final case class TestLens[+A]() extends Product with Serializable
74.  implicit final class TestLensAnyOps[A] extends AnyVal
75.  implicit final class TestLensCauseOps[E] extends AnyVal
76.  implicit final class TestLensEitherOps[E, A] extends AnyVal
77.  implicit final class TestLensExitOps[E, A] extends AnyVal
78.  implicit final class TestLensOptionOps[A] extends AnyVal
79.  trait TestLogger extends Serializable
80.  trait TestRandom extends Random with Restorable

    TestRandom allows for deterministically testing effects involving randomness.

    TestRandom allows for deterministically testing effects involving randomness.

    TestRandom operates in two modes. In the first mode, TestRandom is a purely functional pseudo-random number generator. It will generate pseudo-random values just like scala.util.Random except that no internal state is mutated. Instead, methods like nextInt describe state transitions from one random state to another that are automatically composed together through methods like flatMap. The random seed can be set using setSeed and TestRandom is guaranteed to return the same sequence of values for any given seed. This is useful for deterministically generating a sequence of pseudo-random values and powers the property based testing functionality in ZIO Test.

    In the second mode, TestRandom maintains an internal buffer of values that can be "fed" with methods such as feedInts and then when random values of that type are generated they will first be taken from the buffer. This is useful for verifying that functions produce the expected output for a given sequence of "random" inputs.

    import zio.Random
    import zio.test.TestRandom
    
    for {
      _ <- TestRandom.feedInts(4, 5, 2)
      x <- Random.nextIntBounded(6)
      y <- Random.nextIntBounded(6)
      z <- Random.nextIntBounded(6)
    } yield x + y + z == 11

    TestRandom will automatically take values from the buffer if a value of the appropriate type is available and otherwise generate a pseudo-random value, so there is nothing you need to do to switch between the two modes. Just generate random values as you normally would to get pseudo-random values, or feed in values of your own to get those values back. You can also use methods like clearInts to clear the buffer of values of a given type so you can fill the buffer with new values or go back to pseudo-random number generation.

81.  type TestReporter[-E] = (zio.Duration, ExecutedSpec[E]) ⇒ URIO[TestLogger, Unit]

    A TestReporter[E] is capable of reporting test results with error type E.

82.  type TestResult = BoolAlgebra[AssertionResult]
83.  final case class TestRunner[R, E](executor: TestExecutor[R, E], runtimeConfig: RuntimeConfig = RuntimeConfig.makeDefault(), reporter: TestReporter[E] = ..., bootstrap: Layer[Nothing, TestLogger with Clock] = ...) extends Product with Serializable

    A TestRunner[R, E] encapsulates all the logic necessary to run specs that require an environment R and may fail with an error E.

    A TestRunner[R, E] encapsulates all the logic necessary to run specs that require an environment R and may fail with an error E. Test runners require a test executor, a runtime configuration, and a reporter.

84.  sealed abstract class TestSuccess extends AnyRef
85.  trait TestSystem extends System with Restorable

    TestSystem supports deterministic testing of effects involving system properties.

    TestSystem supports deterministic testing of effects involving system properties. Internally, TestSystem maintains mappings of environment variables and system properties that can be set and accessed. No actual environment variables or system properties will be accessed or set as a result of these actions.

    import zio.system
    import zio.test.TestSystem
    
    for {
      _      <- TestSystem.putProperty("java.vm.name", "VM")
      result <- system.property("java.vm.name")
    } yield result == Some("VM")

86.  final case class TestTimeoutException(message: String) extends Throwable with Product with Serializable
87.  trait TimeVariants extends AnyRef
88.  trait TimeoutVariants extends AnyRef
89.  sealed trait Trace[+A] extends AnyRef
90.  abstract class ZIOSpec[R] extends ZIOSpecAbstract
91.  abstract class ZIOSpecAbstract extends ZIOApp

    Annotations

    @EnableReflectiveInstantiation()

92.  abstract class ZIOSpecDefault extends ZIOSpec[TestEnvironment]
93.  type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]

    A ZSpec[R, E] is the canonical spec for testing ZIO programs.

    A ZSpec[R, E] is the canonical spec for testing ZIO programs. The spec's test type is a ZIO effect that requires an R and might fail with an E.

94.  type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]

    A ZTest[R, E] is an effectfully produced test that requires an R and may fail with an E.

95.  type ZTestEnv = TestClock with TestConsole with TestRandom with TestSystem

    A ZRTestEnv is an alias for all ZIO provided Restorable TestEnvironment objects

96.  sealed trait ZTestLogger[-Message, +Output] extends ZLogger[Message, Output]

    A ZTestLogger is an implementation of a ZLogger that writes all log messages to an internal data structure.

    A ZTestLogger is an implementation of a ZLogger that writes all log messages to an internal data structure. The contents of this data structure can be accessed using the logOutput operator. This makes it easy to write tests to verify that expected messages are being logged.

    test("logging works") {
      for {
        _      <- ZIO.logDebug("It's alive!")
        output <- ZTestLogger.logOutput
      } yield assertTrue(output.length == 1) &&
        assertTrue(output(0).message() == "It's alive!") &&
        assertTrue(output(0).logLevel == LogLevel.Debug)
    }

97.  class DefaultMutableRunnableSpec extends MutableRunnableSpec[Any]

    Syntax for writing test like

    Syntax for writing test like

    object MySpec extends DefaultMutableRunnableSpec {
      suite("foo") {
        test("name") {
        } @@ ignore
    
        test("name 2")
      }
      suite("another suite") {
        test("name 3")
      }
    }

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use DefaultRunnableSpec

98.  class MutableRunnableSpec[R] extends RunnableSpec[TestEnvironment, Any]

    Syntax for writing test like

    Syntax for writing test like

    object MySpec extends MutableRunnableSpec(layer, aspect) {
      suite("foo") {
        test("name") {
        } @@ ignore
    
        test("name 2")
      }
      suite("another suite") {
        test("name 3")
      }
    }

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use RunnableSpec