Package

zio

test

Permalink

package test

_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

object MyTest extends ZIOSpecDefault {
  def spec = suite("clock")(
    test("time is non-zero") {
      for {
        time <- Live.live(nanoTime)
      } yield assertTrue(time >= 0L)
    }
  )
}
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. test
  2. CompileVariants
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait Annotations extends Serializable

    Permalink

    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.

  2. final case class Assertion[-A](arrow: TestArrow[A, Boolean]) extends Product with Serializable

    Permalink
  3. trait AssertionVariants extends AnyRef

    Permalink
  4. trait CheckConstructor[Environment, In] extends AnyRef

    Permalink
  5. trait CheckConstructorLowPriority1 extends CheckConstructorLowPriority2

    Permalink
  6. trait CheckConstructorLowPriority2 extends AnyRef

    Permalink
  7. trait CompileVariants extends AnyRef

    Permalink
  8. final class CustomAssertion[A, B] extends AnyRef

    Permalink

    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)
      }
    )
  9. sealed abstract class Eql[A, B] extends AnyRef

    Permalink

    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( ... )
  10. sealed trait ErrorMessage extends AnyRef

    Permalink
  11. sealed trait ExecutionEvent extends AnyRef

    Permalink
  12. trait ExecutionEventConsolePrinter extends AnyRef

    Permalink
  13. trait ExecutionEventSink extends AnyRef

    Permalink
  14. case class FailureCase(errorMessage: Message, codeString: String, location: String, path: Chunk[(String, String)], span: Span, nestedFailures: Chunk[FailureCase], result: Any, customLabel: Option[String]) extends Product with Serializable

    Permalink
  15. trait FunctionVariants extends AnyRef

    Permalink
  16. final case class Gen[-R, +A](sample: ZStream[R, Nothing, Option[Sample[R, A]]]) extends Product with Serializable

    Permalink

    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.

  17. sealed abstract class GenFailureDetails extends AnyRef

    Permalink

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

  18. trait GenZIO extends AnyRef

    Permalink
  19. trait Live extends AnyRef

    Permalink

    The Live trait provides access to the "live" default ZIO services from within ZIO Test for workflows such as printing test results to the console or timing out tests where it is necessary to access the real implementations of these services.

    The Live trait provides access to the "live" default ZIO services from within ZIO Test for workflows such as printing test results to the console or timing out tests where it is necessary to access the real implementations of these services.

    The easiest way to access the "live" services is to use the live method with a workflow that would otherwise use the test version of the default ZIO services.

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

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

  20. trait PrettyPrintVersionSpecific extends AnyRef

    Permalink
  21. final class ProvideSomePartiallyApplied[R0, -R, +E] extends AnyVal

    Permalink
  22. final class ProvideSomeSharedPartiallyApplied[R0, -R, +E] extends AnyVal

    Permalink
  23. trait ReporterEventRenderer extends AnyRef

    Permalink
  24. trait Restorable extends Serializable

    Permalink
  25. sealed trait Result[+A] extends AnyRef

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

    Permalink

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

  27. trait Sized extends Serializable

    Permalink
  28. class SmartAssertMacros extends AnyRef

    Permalink
  29. implicit final class SmartAssertionOps[A] extends AnyVal

    Permalink
  30. class SmartSpecMacros extends AnyRef

    Permalink
  31. final case class Spec[-R, +E](caseValue: SpecCase[R, E, Spec[R, E]]) extends SpecVersionSpecific[R, E] with Product with Serializable

    Permalink

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

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

  32. class SpecLayerMacros extends LayerMacroUtils

    Permalink
  33. trait SuiteConstructor[In] extends AnyRef

    Permalink
  34. trait SuiteConstructorLowPriority1 extends SuiteConstructorLowPriority2

    Permalink
  35. trait SuiteConstructorLowPriority2 extends SuiteConstructorLowPriority3

    Permalink
  36. trait SuiteConstructorLowPriority3 extends SuiteConstructorLowPriority4

    Permalink
  37. trait SuiteConstructorLowPriority4 extends AnyRef

    Permalink
  38. case class SuiteId(id: Int) extends Product with Serializable

    Permalink

    id

    Level of the spec nesting that you are at. Suites get new values, test cases inherit their suite's

  39. final case class Summary(success: Int, fail: Int, ignore: Int, failureDetails: String, duration: zio.Duration = Duration.Zero) extends Product with Serializable

    Permalink
  40. final class TestAnnotation[V] extends Serializable

    Permalink

    A type of annotation.

  41. final class TestAnnotationMap extends AnyRef

    Permalink

    An annotation map keeps track of annotations of different types.

  42. sealed abstract class TestAnnotationRenderer extends AnyRef

    Permalink

    A TestAnnotationRenderer knows how to render test annotations.

  43. sealed trait TestArrow[-A, +B] extends AnyRef

    Permalink
  44. abstract class TestAspect[+LowerR, -UpperR, +LowerE, -UpperE] extends AnyRef

    Permalink

    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.

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

    Permalink

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

  46. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]

    Permalink

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

  47. trait TestClock extends Clock with Restorable

    Permalink

    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.

  48. trait TestClockPlatformSpecific extends AnyRef

    Permalink
  49. trait TestConfig extends Serializable

    Permalink

    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.

  50. trait TestConsole extends Console with Restorable

    Permalink

    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")
  51. trait TestConstructor[-Environment, In] extends AnyRef

    Permalink
  52. trait TestConstructorLowPriority1 extends TestConstructorLowPriority2

    Permalink
  53. trait TestConstructorLowPriority2 extends AnyRef

    Permalink
  54. sealed trait TestDuration extends AnyRef

    Permalink
  55. type TestEnvironment = Annotations with Live with Sized with TestConfig

    Permalink
  56. abstract class TestExecutor[+R, E] extends AnyRef

    Permalink

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

  57. sealed abstract class TestFailure[+E] extends AnyRef

    Permalink
  58. final case class TestLens[+A]() extends Product with Serializable

    Permalink
  59. implicit final class TestLensAnyOps[A] extends AnyVal

    Permalink
  60. implicit final class TestLensCauseOps[E] extends AnyVal

    Permalink
  61. implicit final class TestLensEitherOps[E, A] extends AnyVal

    Permalink
  62. implicit final class TestLensExitOps[E, A] extends AnyVal

    Permalink
  63. implicit final class TestLensOptionOps[A] extends AnyVal

    Permalink
  64. trait TestLogger extends Serializable

    Permalink
  65. trait TestOutput extends AnyRef

    Permalink
  66. trait TestRandom extends Random with Restorable

    Permalink

    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.

  67. case class TestReporters(reportersStack: Ref[List[SuiteId]]) extends Product with Serializable

    Permalink
  68. case class TestResult(arrow: TestArrow[Any, Boolean]) extends Product with Serializable

    Permalink
  69. implicit final class TestResultZIOOps[R, E] extends AnyVal

    Permalink
  70. final case class TestRunner[R, E](executor: TestExecutor[R, E], bootstrap: ULayer[TestOutput with ExecutionEventSink] = TestRunner.defaultBootstrap) extends Product with Serializable

    Permalink

    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.

  71. sealed abstract class TestSuccess extends AnyRef

    Permalink
  72. trait TestSystem extends System with Restorable

    Permalink

    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")
  73. final case class TestTimeoutException(message: String) extends Throwable with Product with Serializable

    Permalink
  74. sealed trait TestTrace[+A] extends AnyRef

    Permalink
  75. trait TimeVariants extends AnyRef

    Permalink
  76. trait TimeoutVariants extends AnyRef

    Permalink
  77. abstract class ZIOSpec[R] extends ZIOSpecAbstract with ZIOSpecVersionSpecific[R]

    Permalink
  78. abstract class ZIOSpecAbstract extends ZIOApp with ZIOSpecAbstractVersionSpecific

    Permalink
    Annotations
    @EnableReflectiveInstantiation()
  79. trait ZIOSpecAbstractVersionSpecific extends AnyRef

    Permalink
  80. abstract class ZIOSpecDefault extends ZIOSpec[TestEnvironment]

    Permalink
  81. trait ZIOSpecVersionSpecific[R] extends AnyRef

    Permalink
  82. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]

    Permalink

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

  83. trait ZTestEventHandler extends AnyRef

    Permalink
  84. sealed trait ZTestLogger[-Message, +Output] extends ZLogger[Message, Output]

    Permalink

    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)
    }

Value Members

  1. object Annotations extends Serializable

    Permalink
  2. object Assertion extends AssertionVariants with Serializable

    Permalink
  3. object CheckConstructor extends CheckConstructorLowPriority1

    Permalink
  4. object CheckVariants

    Permalink
  5. object CompileVariants

    Permalink

    Proxy methods to call package private methods from the macro

  6. object CustomAssertion

    Permalink
  7. object Eql extends EqlLowPriority

    Permalink
  8. object ErrorMessage

    Permalink
  9. object ExecutionEvent

    Permalink
  10. object ExecutionEventConsolePrinter

    Permalink
  11. object ExecutionEventSink

    Permalink
  12. object FailureCase extends Serializable

    Permalink
  13. object Gen extends GenZIO with FunctionVariants with TimeVariants with Serializable

    Permalink
  14. object GenFailureDetails

    Permalink
  15. object Live

    Permalink
  16. object ReporterEventRenderer

    Permalink
  17. object Result

    Permalink
  18. object Sample extends Serializable

    Permalink
  19. object Sized extends Serializable

    Permalink
  20. object Spec extends Serializable

    Permalink
  21. object SuiteConstructor extends SuiteConstructorLowPriority1

    Permalink
  22. object SuiteId extends Serializable

    Permalink
  23. object Summary extends Serializable

    Permalink
  24. object SummaryBuilder

    Permalink
  25. object TestAnnotation extends Serializable

    Permalink
  26. object TestAnnotationMap

    Permalink
  27. object TestAnnotationRenderer

    Permalink
  28. object TestArrow

    Permalink
  29. object TestAspect extends TimeoutVariants

    Permalink
  30. object TestClock extends Serializable

    Permalink
  31. object TestConfig extends Serializable

    Permalink
  32. object TestConsole extends Serializable

    Permalink
  33. object TestConstructor extends TestConstructorLowPriority1

    Permalink
  34. object TestDuration

    Permalink
  35. object TestEnvironment extends Serializable

    Permalink
  36. object TestExecutor

    Permalink
  37. object TestFailure

    Permalink
  38. object TestLogger extends Serializable

    Permalink
  39. object TestOutput

    Permalink
  40. object TestPlatform

    Permalink

    TestPlatform provides information about the platform tests are being run on to enable platform specific test configuration.

  41. object TestRandom extends Serializable

    Permalink
  42. object TestReporters extends Serializable

    Permalink
  43. object TestResult extends Serializable

    Permalink
  44. object TestRunner extends Serializable

    Permalink
  45. object TestServices

    Permalink
  46. object TestSuccess

    Permalink
  47. object TestSystem extends Serializable

    Permalink
  48. object TestTrace

    Permalink
  49. object TestVersion

    Permalink

    TestVersion provides information about the Scala version tests are being run on to enable platform specific test configuration.

  50. object ZTest extends Serializable

    Permalink
  51. object ZTestEventHandler

    Permalink
  52. object ZTestLogger

    Permalink
  53. def annotations(implicit trace: Trace): UIO[Annotations]

    Permalink

    Retrieves the Annotations service for this test.

  54. def annotationsWith[R, E, A](f: (Annotations) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the Annotations service for this test and uses it to run the specified workflow.

  55. macro def assert[A](expr: ⇒ A)(assertion: Assertion[A]): TestResult

    Permalink

    Checks the assertion holds for the given value.

    Checks the assertion holds for the given value.

    Definition Classes
    CompileVariants
  56. def assertCompletes(implicit trace: Trace, sourceLocation: SourceLocation): TestResult

    Permalink

    Asserts that the given test was completed.

  57. def assertCompletesZIO(implicit trace: Trace, sourceLocation: SourceLocation): UIO[TestResult]

    Permalink

    Asserts that the given test was completed.

  58. def assertNever(message: String)(implicit trace: Trace, sourceLocation: SourceLocation): TestResult

    Permalink

    Asserts that the given test was never completed.

  59. macro def assertTrue(expr: Boolean): TestResult

    Permalink
    Definition Classes
    CompileVariants
  60. macro def assertTrue(expr: Boolean, exprs: Boolean*): TestResult

    Permalink

    Checks the assertion holds for the given value.

    Checks the assertion holds for the given value.

    Definition Classes
    CompileVariants
  61. def assertZIO[R, E, A](effect: ZIO[R, E, A])(assertion: Assertion[A])(implicit trace: Trace, sourceLocation: SourceLocation): ZIO[R, E, TestResult]

    Permalink

    Checks the assertion holds for the given effectfully-computed value.

    Checks the assertion holds for the given effectfully-computed value.

    Definition Classes
    CompileVariants
  62. def check[R <: ZAny, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I])(test: (A, B, C, D, F, G, H, I) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts eight random variables.

  63. def check[R <: ZAny, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H])(test: (A, B, C, D, F, G, H) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts seven random variables.

  64. def check[R <: ZAny, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G])(test: (A, B, C, D, F, G) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts six random variables.

  65. def check[R <: ZAny, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F])(test: (A, B, C, D, F) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts five random variables.

  66. def check[R <: ZAny, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts four random variables.

  67. def check[R <: ZAny, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts three random variables.

  68. def check[R <: ZAny, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of check that accepts two random variables.

  69. def check[R <: ZAny, A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    Checks the test passes for "sufficient" numbers of samples from the given random variable.

  70. def checkAll[R <: ZAny, E, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I])(test: (A, B, C, D, F, G, H, I) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts eight random variables.

  71. def checkAll[R <: ZAny, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H])(test: (A, B, C, D, F, G, H) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts seven random variables.

  72. def checkAll[R <: ZAny, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G])(test: (A, B, C, D, F, G) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts six random variables.

  73. def checkAll[R <: ZAny, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F])(test: (A, B, C, D, F) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts five random variables.

  74. def checkAll[R <: ZAny, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts four random variables.

  75. def checkAll[R <: ZAny, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts three random variables.

  76. def checkAll[R <: ZAny, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAll that accepts two random variables.

  77. def checkAll[R <: ZAny, A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    Checks the test passes for all values from the given finite, deterministic generator.

    Checks the test passes for all values from the given finite, deterministic generator. For non-deterministic or infinite generators use check or checkN.

  78. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I], parallelism: Int)(test: (A, B, C, D, F, G, H, I) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts six random variables.

  79. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], parallelism: Int)(test: (A, B, C, D, F, G, H) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts six random variables.

  80. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], parallelism: Int)(test: (A, B, C, D, F, G) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts six random variables.

  81. def checkAllPar[R <: ZAny, E, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], parallelism: Int)(test: (A, B, C, D, F) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts five random variables.

  82. def checkAllPar[R <: ZAny, E, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], parallelism: Int)(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts four random variables.

  83. def checkAllPar[R <: ZAny, E, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], parallelism: Int)(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts three random variables.

  84. def checkAllPar[R <: ZAny, E, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    A version of checkAllPar that accepts two random variables.

  85. def checkAllPar[R <: ZAny, E, A, In](rv: Gen[R, A], parallelism: Int)(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Permalink

    Checks in parallel the effectual test passes for all values from the given random variable.

    Checks in parallel the effectual test passes for all values from the given random variable. This is useful for deterministic Gen that comprehensively explore all possibilities in a given domain.

  86. def checkN(n: Int): CheckN

    Permalink

    Checks the test passes for the specified number of samples from the given random variable.

  87. lazy val defaultTestRunner: TestRunner[TestEnvironment, Any]

    Permalink

    A Runner that provides a default testable environment.

  88. package diff

    Permalink
  89. def failed[E](cause: Cause[E])(implicit trace: Trace): ZIO[Any, TestFailure[E], Nothing]

    Permalink

    Creates a failed test result with the specified runtime cause.

  90. val ignored: UIO[TestSuccess]

    Permalink

    Creates an ignored test result.

  91. package internal

    Permalink
  92. package laws

    Permalink

    The laws package provides functionality for describing laws as values.

    The laws package provides functionality for describing laws as values. The fundamental abstraction is a set of ZLaws[Caps, R]. These laws model the laws that instances having a capability of type Caps are expected to satisfy. A capability Caps[_] is an abstraction describing some functionality that is common across different data types and obeys certain laws. For example, we can model the capability of two values of a type being compared for equality as follows:

    trait Equal[-A] {
      def equal(a1: A, a2: A): Boolean
    }

    Definitions of equality are expected to obey certain laws:

    1. Reflexivity - a1 === a1
    2. Symmetry - a1 === a2 ==> a2 === a1
    3. Transitivity - (a1 === a2) && (a2 === a3) ==> (a1 === a3)

    These laws define what the capabilities mean and ensure that it is safe to abstract across different instances with the same capability.

    Using ZIO Test, we can represent these laws as values. To do so, we define each law using one of the ZLaws constructors. For example:

    val transitivityLaw = ZLaws.Laws3[Equal]("transitivityLaw") {
      def apply[A: Equal](a1: A, a2: A, a3: A): TestResult =
        ???
    }

    We can then combine laws using the + operator:

    val reflexivityLaw: = ???
    val symmetryLaw:    = ???
    
    val equalLaws = reflexivityLaw + symmetryLaw + transitivityLaw

    Laws have a run method that takes a generator of values of type A and checks that those values satisfy the laws. In addition, objects can extend ZLawful to provide an even more convenient syntax for users to check that instances satisfy certain laws.

    object Equal extends Lawful[Equal]
    
    object Hash extends Lawful[Hash]
    
    object Ord extends Lawful[Ord]
    
    checkAllLaws(Equal + Hash + Ord)(Gen.int)

    Note that capabilities compose seamlessly because of contravariance. We can combine laws describing different capabilities to construct a set of laws requiring that instances having all of the capabilities satisfy each of the laws.

  93. def live(implicit trace: Trace): UIO[Live]

    Permalink

    Retrieves the Live service for this test.

  94. def live[R, E, A](zio: ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Provides an effect with the "real" environment as opposed to the test environment.

    Provides an effect with the "real" environment as opposed to the test environment. This is useful for performing effects such as timing out tests, accessing the real time, or printing to the real console.

  95. val liveEnvironment: Layer[Nothing, Clock with Console with System with Random]

    Permalink
  96. def liveWith[R, E, A](f: (Live) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the Live service for this test and uses it to run the specified workflow.

  97. def platformSpecific[R, E, A](js: ⇒ A, jvm: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]

    Permalink

    Passes platform specific information to the specified function, which will use that information to create a test.

    Passes platform specific information to the specified function, which will use that information to create a test. If the platform is neither ScalaJS nor the JVM, an ignored test result will be returned.

  98. package poly

    Permalink
  99. package render

    Permalink
  100. package results

    Permalink
  101. def sized(implicit trace: Trace): UIO[Sized]

    Permalink

    Retrieves the Sized service for this test.

  102. def sizedWith[R, E, A](f: (Sized) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the Sized service for this test and uses it to run the specified workflow.

  103. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], sourceLocation: SourceLocation, trace: Trace): Spec[OutEnvironment, OutError]

    Permalink

    Builds a suite containing a number of other specs.

  104. def test[In](label: String)(assertion: ⇒ In)(implicit testConstructor: TestConstructor[Nothing, In], sourceLocation: SourceLocation, trace: Trace): Out

    Permalink

    Builds a spec with a single test.

  105. def testClock(implicit trace: Trace): UIO[TestClock]

    Permalink

    Retrieves the TestClock service for this test.

  106. def testClockWith[R, E, A](f: (TestClock) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the TestClock service for this test and uses it to run the specified workflow.

  107. def testConfig(implicit trace: Trace): UIO[TestConfig]

    Permalink

    Retrieves the TestConfig service for this test.

  108. def testConfigWith[R, E, A](f: (TestConfig) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the TestConfig service for this test and uses it to run the specified workflow.

  109. def testConsole(implicit trace: Trace): UIO[TestConsole]

    Permalink

    Retrieves the TestConsole service for this test.

  110. def testConsoleWith[R, E, A](f: (TestConsole) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the TestConsole service for this test and uses it to run the specified workflow.

  111. val testEnvironment: ZLayer[Any, Nothing, TestEnvironment]

    Permalink
  112. def testRandom(implicit trace: Trace): UIO[TestRandom]

    Permalink

    Retrieves the TestRandom service for this test.

  113. def testRandomWith[R, E, A](f: (TestRandom) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the TestRandom service for this test and uses it to run the specified workflow.

  114. def testSystem(implicit trace: Trace): UIO[TestSystem]

    Permalink

    Retrieves the TestSystem service for this test.

  115. def testSystemWith[R, E, A](f: (TestSystem) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Permalink

    Retrieves the TestSystem service for this test and uses it to run the specified workflow.

  116. final macro def typeCheck(code: String): UIO[Either[String, Unit]]

    Permalink

    Returns either Right if the specified string type checks as valid Scala code or Left with an error message otherwise.

    Returns either Right if the specified string type checks as valid Scala code or Left with an error message otherwise. Dies with a runtime exception if specified string cannot be parsed or is not a known value at compile time.

    Definition Classes
    CompileVariants
  117. def versionSpecific[R, E, A](scala3: ⇒ A, scala2: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]

    Permalink

    Passes version specific information to the specified function, which will use that information to create a test.

    Passes version specific information to the specified function, which will use that information to create a test. If the version is neither Scala 3 nor Scala 2, an ignored test result will be returned.

  118. def withAnnotations[R, E, A <: Annotations, B](annotations: ⇒ A)(zio: ⇒ ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Permalink

    Executes the specified workflow with the specified implementation of the annotations service.

  119. def withAnnotationsScoped[A <: Annotations](annotations: ⇒ A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Permalink

    Sets the implementation of the annotations service to the specified value and restores it to its original value when the scope is closed.

  120. def withLive[R, E, E1, A, B](zio: ZIO[R, E, A])(f: (ZIO[R, E, A]) ⇒ ZIO[R, E1, B])(implicit trace: Trace): ZIO[R, E1, B]

    Permalink

    Transforms this effect with the specified function.

    Transforms this effect with the specified function. The test environment will be provided to this effect, but the live environment will be provided to the transformation function. This can be useful for applying transformations to an effect that require access to the "real" environment while ensuring that the effect itself uses the test environment.

    withLive(test)(_.timeout(duration))
  121. def withLive[R, E, A <: Live, B](live: ⇒ A)(zio: ⇒ ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Permalink

    Executes the specified workflow with the specified implementation of the live service.

  122. def withLiveScoped[A <: Live](live: ⇒ A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Permalink

    Sets the implementation of the live service to the specified value and restores it to its original value when the scope is closed.

  123. def withSized[R, E, A <: Sized, B](sized: ⇒ A)(zio: ⇒ ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Permalink

    Executes the specified workflow with the specified implementation of the sized service.

  124. def withSizedScoped[A <: Sized](sized: ⇒ A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Permalink

    Sets the implementation of the sized service to the specified value and restores it to its original value when the scope is closed.

  125. def withTestConfig[R, E, A <: TestConfig, B](testConfig: ⇒ A)(zio: ⇒ ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Permalink

    Executes the specified workflow with the specified implementation of the config service.

  126. def withTestConfigScoped[A <: TestConfig](testConfig: ⇒ A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Permalink

    Sets the implementation of the config service to the specified value and restores it to its original value when the scope is closed.

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped