Packages

  • package root
    Definition Classes
    root
  • package zio
    Definition Classes
    root
  • package test

    _ZIO Test_ is a featherweight testing library for effectful programs.

    _ZIO Test_ is a featherweight testing library for effectful programs.

    The library imagines every spec as an ordinary immutable value, providing tremendous potential for composition. Thanks to tight integration with ZIO, specs can use resources (including those requiring disposal), have well- defined linear and parallel semantics, and can benefit from a host of ZIO combinators.

    import zio.test._
import zio.clock.nanoTime
import Assertion.isGreaterThan

object MyTest extends DefaultRunnableSpec {
  def spec = suite("clock")(
    testM("time is non-zero") {
      assertM(nanoTime)(isGreaterThan(0))
    }
  )
}
    Definition Classes
    zio
  • package environment

    The environment package contains testable versions of all the standard ZIO environment types through the TestClock, TestConsole, TestSystem, and TestRandom modules.

    The environment package contains testable versions of all the standard ZIO environment types through the TestClock, TestConsole, TestSystem, and TestRandom modules. See the documentation on the individual modules for more detail about using each of them.

    If you are using ZIO Test and extending RunnableSpec a TestEnvironment containing all of them will be automatically provided to each of your tests. Otherwise, the easiest way to use the test implementations in ZIO Test is by providing the TestEnvironment to your program.

    import zio.test.environment._

myProgram.provideLayer(testEnvironment)

    Then all environmental effects, such as printing to the console or generating random numbers, will be implemented by the TestEnvironment and will be fully testable. When you do need to access the "live" environment, for example to print debugging information to the console, just use the live combinator along with the effect as your normally would.

    If you are only interested in one of the test implementations for your application, you can also access them a la carte through the make method on each module. Each test module requires some data on initialization. Default data is included for each as DefaultData.

    import zio.test.environment._

myProgram.provideM(TestConsole.make(TestConsole.DefaultData))

    Finally, you can create a Test object that implements the test interface directly using the makeTest method. This can be useful when you want to access some testing functionality without using the environment type.

    import zio.test.environment._

for {
  testRandom <- TestRandom.makeTest(TestRandom.DefaultData)
  n          <- testRandom.nextInt
} yield n

    This can also be useful when you are creating a more complex environment to provide the implementation for test services that you mix in.

    Definition Classes
    test
  • package mock
    Definition Classes
    test
  • package internal
  • ArgumentExpectation
  • Expectation
  • Invocation
  • Method
  • MockClock
  • MockConsole
  • MockRandom
  • MockSystem
  • Mockable
  • Proxy
  • ReturnExpectation
  • package poly
    Definition Classes
    test
  • package reflect
    Definition Classes
    test

package mock

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. Protected

Package Members

  1. package internal

Type Members

  1. final case class ArgumentExpectation[R <: Has[_], I, A](method: Method[R, I, A], assertion: Assertion[I])(implicit evidence$1: zio.Tagged[R]) extends Product with Serializable

    An ArgumentExpectation[R, I, A] represents an expectation on input I arguments for environment R that returns an effect that may produce a single A.

  2. sealed trait Expectation[R <: Has[_]] extends AnyRef

    An Expectation[R] is an immutable tree structure that represents expectations on environment R.

  3. final case class Invocation[R <: Has[_], I, A](method: Method[R, I, A], input: I, output: A) extends Product with Serializable

    An Invocation[R, I, A] models a single invocation of a Method[R, I, A], including both the input to the method invocation I and the output from the method invocation A.

  4. abstract class Method[R <: Has[_], I, A] extends AnyRef

    A Model[R, I, A] represents a capability of environment R that takes an input I and returns an effect that may produce a single A.

  5. macro class Mockable[A] extends Annotation with StaticAnnotation
    Annotations
    @compileTimeOnly("enable macro paradise to expand macro annotations")
  6. trait Proxy extends AnyRef

    A Proxy provides the machinery to map mocked invocations to predefined results and check some constraints on the way.

  7. sealed trait ReturnExpectation[-I, +E, +A] extends AnyRef

    A ReturnExpectation[-I, E, +A] represents an expectation on output that given input arguments I returns an effect that may fail with an error E or produce a single A.

Value Members

  1. object Expectation
  2. object MockClock
  3. object MockConsole
  4. object MockRandom
  5. object MockSystem
  6. object ReturnExpectation

Ungrouped