zio.test.laws
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:
- Reflexivity -
a1 === a1
- Symmetry -
a1 === a2 ==> a2 === a1
- 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.