pyfect-dev 0.1.0__py3-none-any.whl

pyfect/testing/_decorators.py

@@ -0,0 +1,211 @@
+"""``@effect`` and ``@live``: pytest tests written as effects."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import functools
+from collections.abc import Callable, Generator
+from typing import Any, Concatenate, Literal, overload
+
+from pyfect._core import Effect, _Gen, _Suspend
+from pyfect.clock import Clock, LiveClock
+from pyfect.console import CurrentConsole
+from pyfect.context import Context
+from pyfect.duration import Duration, Seconds, to_seconds
+from pyfect.run import unwrap
+from pyfect.scope import Scope, scoped
+from pyfect.testing._clock import TestClock
+from pyfect.testing._console import TestConsole
+from pyfect.testing._layers import Services
+from pyfect.testing._runtime import AsyncioRuntime, Runtime, SyncRuntime
+
+type TestBody[R] = Generator[Effect[Any, Any, R], Any, object] | Effect[object, object, R]
+"""What a test function gives: a generator of effects (``yield from``), or
+an effect. Any typed error fails the test."""
+
+
+class Settings:
+    """Defaults the pytest plugin reads from the ini file."""
+
+    timeout: Seconds | None = Seconds(5.0)
+
+
+settings = Settings()
+
+type _Mode = Literal["effect", "live"]
+
+
+class _Options:
+    __slots__ = ("asyncio", "mode", "timeout", "warning_delay")
+
+    def __init__(
+        self, mode: _Mode, timeout: Duration | None, asyncio: bool, warning_delay: Duration
+    ) -> None:
+        self.mode: _Mode = mode
+        self.timeout = None if timeout is None else to_seconds(timeout)
+        self.asyncio = asyncio
+        self.warning_delay = warning_delay
+
+
+class TestDecorator:
+    """``@effect(...)`` / ``@live(...)`` with options."""
+
+    __test__ = False
+    __slots__ = ("_options",)
+
+    def __init__(self, options: _Options) -> None:
+        self._options = options
+
+    @overload
+    def __call__[RO, **P](
+        self, f: Callable[Concatenate[Services[RO], P], TestBody[RO | Scope]], /
+    ) -> Callable[Concatenate[Services[RO], P], None]: ...
+    @overload
+    def __call__[S, RO, **P](
+        self, f: Callable[Concatenate[S, Services[RO], P], TestBody[RO | Scope]], /
+    ) -> Callable[Concatenate[S, Services[RO], P], None]: ...
+    @overload
+    def __call__[**P](self, f: Callable[P, TestBody[Scope]], /) -> Callable[P, None]: ...
+    def __call__(self, f: Callable[..., Any], /) -> Callable[..., None]:
+        return _make_test(f, self._options)
+
+
+@overload
+def effect[RO, **P](
+    f: Callable[Concatenate[Services[RO], P], TestBody[RO | Scope]], /
+) -> Callable[Concatenate[Services[RO], P], None]: ...
+@overload
+def effect[S, RO, **P](
+    f: Callable[Concatenate[S, Services[RO], P], TestBody[RO | Scope]], /
+) -> Callable[Concatenate[S, Services[RO], P], None]: ...
+@overload
+def effect[**P](f: Callable[P, TestBody[Scope]], /) -> Callable[P, None]: ...
+@overload
+def effect(
+    *, timeout: Duration | None = None, asyncio: bool = False, warning_delay: Duration = 1.0
+) -> TestDecorator: ...
+def effect(
+    f: Callable[..., Any] | None = None,
+    /,
+    *,
+    timeout: Duration | None = None,
+    asyncio: bool = False,
+    warning_delay: Duration = 1.0,
+) -> Any:
+    """A pytest test written as an effect, run with a ``TestClock``, a
+    ``TestConsole`` and a ``Scope`` (closed when the test ends)::
+
+        @effect
+        def test_retries():
+            fiber = yield from flaky_call.retry(spaced(1)).fork()
+            yield from adjust(3)
+            assert (yield from fiber.join()) == "ok"
+
+    ``timeout`` (real time; default from the ``pyfect_timeout`` ini option)
+    interrupts the test and runs its finalizers. ``asyncio`` runs it on an
+    event loop, for ``from_async``. A first parameter annotated
+    ``Services[...]`` (a ``layer_fixture``; in a test class, the parameter
+    after ``self``) provides those services."""
+    decorator = TestDecorator(_Options("effect", timeout, asyncio, warning_delay))
+    return decorator if f is None else decorator(f)
+
+
+@overload
+def live[RO, **P](
+    f: Callable[Concatenate[Services[RO], P], TestBody[RO | Scope]], /
+) -> Callable[Concatenate[Services[RO], P], None]: ...
+@overload
+def live[S, RO, **P](
+    f: Callable[Concatenate[S, Services[RO], P], TestBody[RO | Scope]], /
+) -> Callable[Concatenate[S, Services[RO], P], None]: ...
+@overload
+def live[**P](f: Callable[P, TestBody[Scope]], /) -> Callable[P, None]: ...
+@overload
+def live(*, timeout: Duration | None = None, asyncio: bool = False) -> TestDecorator: ...
+def live(
+    f: Callable[..., Any] | None = None,
+    /,
+    *,
+    timeout: Duration | None = None,
+    asyncio: bool = False,
+) -> Any:
+    """Like ``effect``, but with the live clock and console: sleeps take
+    real time and output is written."""
+    decorator = TestDecorator(_Options("live", timeout, asyncio, 1.0))
+    return decorator if f is None else decorator(f)
+
+
+def _make_test(f: Callable[..., Any], options: _Options) -> Callable[..., None]:
+    import pytest
+
+    @functools.wraps(f)
+    def test(*args: Any, **kwargs: Any) -> None:
+        services = _services_in(args, kwargs)
+        runtime = _runtime_for(services, options)
+        context, clock = _context_for(services, options)
+        timeout = options.timeout if options.timeout is not None else settings.timeout
+        try:
+            ex = runtime.run(scoped(_body(f, args, kwargs)), context, timeout=timeout)
+        finally:
+            if clock is not None:
+                clock.stop_warning()
+            if services is None:
+                runtime.close()
+        unwrap(ex)
+
+    marker = pytest.mark.pyfect_live if options.mode == "live" else pytest.mark.pyfect_effect
+    return marker(test)
+
+
+def _services_in(args: tuple[Any, ...], kwargs: dict[str, Any]) -> Services[Any] | None:
+    found: list[Services[Any]] = [a for a in (*args, *kwargs.values()) if isinstance(a, Services)]
+    if len(found) > 1:
+        raise TypeError(
+            "a test can use one layer_fixture; merge the layers into one with layer.merge"
+        )
+    return found[0] if found else None
+
+
+def _runtime_for(services: Services[Any] | None, options: _Options) -> Runtime:
+    if services is None:
+        return AsyncioRuntime() if options.asyncio else SyncRuntime()
+    if options.asyncio != isinstance(services.runtime, AsyncioRuntime):
+        raise TypeError(
+            "the test and its layer_fixture must agree on asyncio=; the test runs on "
+            "the fixture's runtime"
+        )
+    return services.runtime
+
+
+def _context_for(
+    services: Services[Any] | None, options: _Options
+) -> tuple[Context, TestClock | None]:
+    """The test's context, and the ``TestClock`` made for this test alone
+    (with a ``TestConsole`` of its own).
+
+    Under a ``layer_fixture`` an ``effect`` test uses the fixture's clock:
+    its ``TestClock``, or the live clock of a ``live=True`` fixture."""
+    context = Context.empty() if services is None else services.context
+    if options.mode == "live":
+        return context.add(Clock, LiveClock()), None
+    if services is not None:
+        return context, None
+    clock = TestClock(warning_delay=options.warning_delay)
+    return context.add(Clock, clock).add(CurrentConsole, TestConsole()), clock
+
+
+def _body(
+    f: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> Effect[Any, Any, Any]:
+    def start() -> Effect[Any, Any, Any]:
+        out = f(*args, **kwargs)
+        if isinstance(out, Effect):
+            return out  # pyright: ignore[reportUnknownVariableType]
+        if isinstance(out, Generator):
+            return _Gen(lambda: out)  # pyright: ignore[reportUnknownLambdaType]
+        raise TypeError(
+            f"{f.__qualname__} must be a generator (use `yield from`) or return an Effect, "
+            f"got {type(out).__name__}"
+        )
+
+    return _Suspend(start)

pyfect/testing/_flaky.py

@@ -0,0 +1,34 @@
+"""``flaky``: retry a test effect that sometimes fails."""
+
+from __future__ import annotations
+
+from typing import Any, Never, overload
+
+from pyfect._core import Effect
+from pyfect._effect_args import require_effect
+from pyfect.cause import Cause, Die, Fail, from_reasons
+from pyfect.duration import Duration
+from pyfect.effect import fail_cause
+from pyfect.schedule import recurs
+from pyfect.scope import Scope, scoped
+
+
+@overload
+def flaky[A, E](eff: Effect[A, E, Scope], timeout: Duration = 30.0) -> Effect[A]: ...
+@overload
+def flaky[A, E, R](
+    eff: Effect[A, E, Scope | R], timeout: Duration = 30.0
+) -> Effect[A, Never, R]: ...
+def flaky(eff: Effect[Any, Any, Any], timeout: Duration = 30.0) -> Effect[Any, Any, Any]:
+    """Retry ``eff`` (in a fresh scope each time) after any failure, defects
+    included, up to 10 times while less than ``timeout`` has passed. Like
+    Effect's ``flakyTest``, the last failure dies: its typed errors become
+    defects, kept with their tracebacks."""
+    require_effect(eff, "eff")
+    policy = recurs(10).up_to(duration=timeout)
+    attempts: Effect[Any, Any, Any] = scoped(eff).sandbox().retry(policy)
+    return attempts.catch_all(lambda cause: fail_cause(_all_defects(cause)))
+
+
+def _all_defects(cause: Cause[Any]) -> Cause[Never]:
+    return from_reasons(Die(r.error) if isinstance(r, Fail) else r for r in cause.reasons)

pyfect/testing/_layers.py

@@ -0,0 +1,153 @@
+"""``layer_fixture`` / ``effect_fixture``: build a layer or run a scoped
+effect once per pytest scope and share the result."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, Literal, Never, final
+
+from pyfect._effect_args import require_effect
+from pyfect._layer_core import require_layer
+from pyfect.clock import Clock
+from pyfect.console import CurrentConsole
+from pyfect.context import Context
+from pyfect.duration import Duration, to_seconds
+from pyfect.effect import Effect, provide_service
+from pyfect.exit import Success
+from pyfect.layer import Layer
+from pyfect.run import unwrap
+from pyfect.scope import CloseableScope, Scope
+from pyfect.testing._clock import TestClock
+from pyfect.testing._console import TestConsole
+from pyfect.testing._runtime import AsyncioRuntime, Runtime, SyncRuntime
+
+if TYPE_CHECKING:
+    from _pytest.fixtures import FixtureFunctionDefinition
+
+type FixtureScope = Literal["function", "class", "module", "package", "session"]
+
+
+@final
+class Services[RO]:
+    """The services a ``layer_fixture`` built, and the runtime they live on.
+
+    Take it as the first parameter of an ``@effect`` test, annotated with
+    what the layer builds; the test may then use those services::
+
+        db = layer_fixture(DatabaseLive)
+
+        @effect
+        def test_query(db: Services[Database]):
+            conn = yield from Database()
+    """
+
+    __slots__ = ("context", "runtime")
+
+    def __init__(self, context: Context, runtime: Runtime) -> None:
+        self.context = context
+        self.runtime = runtime
+
+
+def layer_fixture[RO, E](
+    layer: Layer[RO, E],
+    *,
+    scope: FixtureScope = "module",
+    live: bool = False,
+    asyncio: bool = False,
+    warning_delay: Duration = 1.0,
+    timeout: Duration | None = None,
+) -> FixtureFunctionDefinition:
+    """A pytest fixture that builds ``layer`` once per ``scope`` and
+    releases its resources when the scope ends.
+
+    The layer is built with a ``TestClock`` and a ``TestConsole`` (shared
+    by every test that uses the fixture), unless ``live``: then it and its
+    ``effect`` tests use the live clock and console. Tests using the fixture run on the
+    fixture's runtime, so fibers the layer forks keep running; ``asyncio``
+    picks an event loop for it, needed by ``from_async``. ``timeout``
+    bounds building and releasing, in real time."""
+    require_layer(layer, "layer")
+
+    def fixture() -> Generator[Services[RO]]:
+        with _held(
+            layer.build_with_scope,
+            live=live,
+            asyncio=asyncio,
+            warning_delay=warning_delay,
+            timeout=timeout,
+        ) as (built, context, runtime):
+            yield Services(context.merge(built), runtime)
+
+    return _fixture(fixture, scope)
+
+
+def effect_fixture[A, E](
+    eff: Effect[A, E, Scope],
+    *,
+    scope: FixtureScope = "function",
+    live: bool = False,
+    asyncio: bool = False,
+    warning_delay: Duration = 1.0,
+    timeout: Duration | None = None,
+) -> FixtureFunctionDefinition:
+    """A pytest fixture whose value is what ``eff`` succeeds with, run once
+    per ``scope``. Finalizers ``eff`` adds to its ``Scope`` run when the
+    scope ends; a failure is raised as the fixture's error.
+
+    The options are ``layer_fixture``'s. The value is a plain Python value,
+    so any test can take it; to share services or forked fibers with
+    ``effect`` tests, use ``layer_fixture``."""
+    require_effect(eff, "eff")
+
+    def fixture() -> Generator[A]:
+        with _held(
+            lambda resources: eff.pipe(provide_service(Scope, resources)),
+            live=live,
+            asyncio=asyncio,
+            warning_delay=warning_delay,
+            timeout=timeout,
+        ) as (value, _context, _runtime):
+            yield value
+
+    return _fixture(fixture, scope)
+
+
+def _fixture(
+    fixture: Callable[[], Generator[Any]], scope: FixtureScope
+) -> FixtureFunctionDefinition:
+    import pytest
+
+    return pytest.fixture(scope=scope)(fixture)
+
+
+@contextmanager
+def _held[T](
+    build: Callable[[CloseableScope], Effect[T, Any, Never]],
+    *,
+    live: bool,
+    asyncio: bool,
+    warning_delay: Duration,
+    timeout: Duration | None,
+) -> Generator[tuple[T, Context, Runtime]]:
+    """Run ``build`` on a fresh runtime and clock, hold what it built, then
+    close its scope and the runtime."""
+    limit = None if timeout is None else to_seconds(timeout)
+    runtime: Runtime = AsyncioRuntime() if asyncio else SyncRuntime()
+    clock = None if live else TestClock(warning_delay=warning_delay)
+    context = (
+        Context.empty()
+        if clock is None
+        else Context.empty().add(Clock, clock).add(CurrentConsole, TestConsole())
+    )
+    resources = CloseableScope()
+    try:
+        built = unwrap(runtime.run(build(resources), context, timeout=limit))
+        yield built, context, runtime
+    finally:
+        closed = runtime.run(resources.close(Success(None)), context, timeout=limit)
+        if clock is not None:
+            clock.stop_warning()
+        runtime.close()
+        unwrap(closed)

pyfect/testing/_prop.py

@@ -0,0 +1,255 @@
+"""Property tests over schemas and Hypothesis strategies (``@effect/vitest``'s
+``it.prop``, ``it.effect.prop`` and ``it.live.prop``)::
+
+    @testing.prop(S.Finite, S.Int)
+    def test_symmetry(a: float, b: int) -> bool:
+        return a + b == b + a
+
+    @testing.effect_prop(text=S.String)
+    def test_echo(text: str):
+        yield from fx.Console.log(text)
+
+Hypothesis runs the property: a schema is drawn with ``S.to_strategy``, a
+strategy as it is. Positional inputs fill the rightmost parameters (as
+``@given``'s do), keyword inputs the parameters they name; the others are
+pytest fixtures. A property returning ``False`` or raising is falsified and
+shrunk. An ``effect_prop`` / ``live_prop`` property is an effect test run
+once per drawn input, each run with its own ``TestClock``, ``TestConsole``
+and ``Scope``: a typed failure or a defect falsifies it, an interruption or
+the ``timeout`` (real time, for the whole check) ends the check without
+shrinking. ``runs`` is Hypothesis's ``max_examples`` and ``seed`` its seed;
+unset, they come from the active Hypothesis settings profile (Effect's
+``Arbitrary.configureGlobal``). Needs the ``pyfect-dev[hypothesis]`` extra.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import functools
+import inspect
+import time
+from collections.abc import Callable, Generator, Mapping
+from typing import TYPE_CHECKING, Any, cast
+
+from pyfect._core import Effect
+from pyfect._extras import missing_extra
+from pyfect.duration import Duration, Seconds
+from pyfect.exit import Failure, Success
+from pyfect.run import unwrap
+from pyfect.schema import Codec, to_strategy
+from pyfect.scope import scoped
+from pyfect.testing._decorators import (
+    TestBody,
+    _body,
+    _context_for,
+    _Mode,
+    _Options,
+    _runtime_for,
+    _services_in,
+)
+from pyfect.testing._decorators import settings as plugin_settings
+
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+type Arbitrary = Codec[Any, Any, Any, Any] | SearchStrategy[Any]
+"""A property input: a schema (drawn with ``S.to_strategy``) or a Hypothesis
+strategy (Effect's ``Arbitrary``)."""
+
+type AnyCodec = Codec[Any, Any, Any, Any]
+type Property = Callable[..., bool | None]
+type _Decorator = Callable[[Callable[..., Any]], Callable[..., None]]
+
+
+class PropertyFalsifiedError(AssertionError):
+    """A property returned ``False``."""
+
+
+class _EndCheck(BaseException):
+    """Ends the whole check: Hypothesis shrinks on ``Exception``s and lets
+    other ``BaseException``s through."""
+
+    def __init__(self, error: BaseException) -> None:
+        super().__init__(error)
+        self.error = error
+
+
+def prop(
+    *arbitraries: Arbitrary,
+    runs: int | None = None,
+    seed: int | None = None,
+    **keyed: Arbitrary,
+) -> Callable[[Property], Callable[..., None]]:
+    """A pytest property test: ``f`` returns ``True`` / ``None`` to pass and
+    ``False`` to falsify; an effect or generator is refused with
+    ``TypeError`` (use ``effect_prop``)."""
+
+    def check(
+        f: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any], started: float
+    ) -> None:
+        out = f(*args, **kwargs)
+        if isinstance(out, Effect | Generator) or not (out is None or isinstance(out, bool)):
+            raise TypeError(
+                "testing.prop properties must return bool or None; "
+                "use testing.effect_prop for effects"
+            )
+        if out is False:
+            raise PropertyFalsifiedError(f"property {f.__qualname__} returned False")
+
+    return _property(arbitraries, keyed, runs, seed, check, mode=None)
+
+
+def effect_prop(
+    *arbitraries: Arbitrary,
+    runs: int | None = None,
+    seed: int | None = None,
+    timeout: Duration | None = None,
+    asyncio: bool = False,
+    warning_delay: Duration = 1.0,
+    **keyed: Arbitrary,
+) -> Callable[[Callable[..., TestBody[Any]]], Callable[..., None]]:
+    """A property test written as an effect (``testing.effect`` per drawn
+    input): it fails with ``False``, a typed failure or a defect."""
+    options = _Options("effect", timeout, asyncio, warning_delay)
+    return _property(arbitraries, keyed, runs, seed, _effect_runner(options), mode="effect")
+
+
+def live_prop(
+    *arbitraries: Arbitrary,
+    runs: int | None = None,
+    seed: int | None = None,
+    timeout: Duration | None = None,
+    asyncio: bool = False,
+    **keyed: Arbitrary,
+) -> Callable[[Callable[..., TestBody[Any]]], Callable[..., None]]:
+    """``effect_prop`` with the live clock and console."""
+    options = _Options("live", timeout, asyncio, 1.0)
+    return _property(arbitraries, keyed, runs, seed, _effect_runner(options), mode="live")
+
+
+type _Check = Callable[[Callable[..., Any], tuple[Any, ...], dict[str, Any], float], None]
+"""Runs the property on one drawn input; ``started`` is when the check
+began (``time.monotonic``)."""
+
+
+def _property(
+    arbitraries: tuple[Arbitrary, ...],
+    keyed: Mapping[str, Arbitrary],
+    runs: int | None,
+    seed: int | None,
+    check: _Check,
+    *,
+    mode: _Mode | None,
+) -> _Decorator:
+    """``mode`` puts the plugin's ``pyfect_effect`` / ``pyfect_live``
+    marker on the test."""
+    import pytest
+
+    try:
+        import hypothesis
+        from hypothesis.strategies import SearchStrategy
+    except ImportError as error:
+        raise missing_extra("testing.prop", "hypothesis") from error
+
+    def decorate(f: Callable[..., Any]) -> Callable[..., None]:
+        strategies = _strategies_for(f, arbitraries, keyed, SearchStrategy)
+        signature = inspect.signature(f)
+        fixtures = [p for name, p in signature.parameters.items() if name not in strategies]
+
+        @functools.wraps(f)
+        def run(*args: Any, **kwargs: Any) -> None:
+            started = time.monotonic()
+
+            @functools.wraps(f)
+            def sample(*args: Any, **kwargs: Any) -> None:
+                check(f, args, kwargs, started)
+
+            # Built per run, so unset options follow the profile loaded now.
+            options = hypothesis.settings(deadline=None)
+            if runs is not None:
+                options = hypothesis.settings(options, max_examples=runs)
+            test = options(hypothesis.given(**strategies)(sample))
+            if seed is not None:
+                test = hypothesis.seed(seed)(test)
+            try:
+                test(*args, **kwargs)
+            except _EndCheck as end:
+                raise end.error from None
+
+        run.__signature__ = signature.replace(parameters=fixtures)  # pyright: ignore[reportAttributeAccessIssue]
+        match mode:
+            case "effect":
+                return pytest.mark.pyfect_effect(run)
+            case "live":
+                return pytest.mark.pyfect_live(run)
+            case None:
+                return run
+
+    return decorate
+
+
+def _strategies_for(
+    f: Callable[..., Any],
+    arbitraries: tuple[Arbitrary, ...],
+    keyed: Mapping[str, Arbitrary],
+    strategy_type: type[SearchStrategy[Any]],
+) -> dict[str, SearchStrategy[Any]]:
+    params = list(inspect.signature(f).parameters)
+    unknown = keyed.keys() - set(params)
+    if unknown:
+        raise TypeError(f"{f.__qualname__} has no parameter(s) {sorted(unknown)}")
+    free = [name for name in params if name not in keyed]
+    if len(arbitraries) > len(free):
+        raise TypeError(
+            f"{f.__qualname__} has {len(free)} parameter(s) left, "
+            f"too few for {len(arbitraries)} positional property inputs"
+        )
+    named = dict(zip(free[len(free) - len(arbitraries) :], arbitraries, strict=True))
+    return {
+        name: input if isinstance(input, strategy_type) else to_strategy(cast("AnyCodec", input))
+        for name, input in {**named, **keyed}.items()
+    }
+
+
+def _effect_runner(options: _Options) -> _Check:
+    """One effect test per drawn input; the timeout is for the whole check."""
+
+    def check(
+        f: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any], started: float
+    ) -> None:
+        limit = options.timeout if options.timeout is not None else plugin_settings.timeout
+        left = None if limit is None else Seconds(max(limit - (time.monotonic() - started), 0.0))
+        _run_sample(f, args, kwargs, options, left)
+
+    return check
+
+
+def _run_sample(
+    f: Callable[..., Any],
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    options: _Options,
+    timeout: Seconds | None,
+) -> None:
+    services = _services_in(args, kwargs)
+    runtime = _runtime_for(services, options)
+    context, clock = _context_for(services, options)
+    try:
+        ex = runtime.run(scoped(_body(f, args, kwargs)), context, timeout=timeout)
+    except TimeoutError as error:
+        raise _EndCheck(error) from None
+    finally:
+        if clock is not None:
+            clock.stop_warning()
+        if services is None:
+            runtime.close()
+    match ex:
+        case Failure(cause=cause) if cause.has_interrupts:
+            raise _EndCheck(cause.raisable())
+        case Success(value=False):
+            raise PropertyFalsifiedError(f"property {f.__qualname__} returned False")
+        case _:
+            unwrap(ex)
+
+
+__all__ = ["Arbitrary", "PropertyFalsifiedError", "effect_prop", "live_prop", "prop"]