hypothesis: extract a pure function for types-to-strategies.

Phew. Finally.

Author: pradeep90

returns/contrib/hypothesis/laws.py

@@ -1,6 +1,6 @@
 import dataclasses
 import inspect
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Mapping
 from contextlib import ExitStack, contextmanager
 from typing import Any, TypeVar, final, overload
 
@@ -209,28 +209,29 @@ def _run_law(
     def factory(source: st.DataObject) -> None:
         with ExitStack() as stack:
             stack.enter_context(clean_plugin_context())
-            _enter_hypothesis_context(stack, container_type, settings)
+            stack.enter_context(
+                strategies_for_types(
+                    _types_to_strategies(container_type, settings)
+                )
+            )
             source.draw(st.builds(law.definition))
 
     return factory
 
 
-def _enter_hypothesis_context(
-    stack: ExitStack,
+def _types_to_strategies(
     container_type: type[Lawful],
     settings: _Settings,
-) -> None:
-    stack.enter_context(
-        strategies_for_types({
-            TypeVar: type_vars_factory,  # type: ignore[dict-item]
-            Callable: pure_functions_factory,  # type: ignore[dict-item]
-            **{
-                interface: _strategy_for_container(container_type, settings)
-                for interface in container_type.laws()
-            },
-            container_type: _strategy_for_container(container_type, settings),
-        })
-    )
+) -> Mapping[type[object], StrategyFactory]:
+    return {
+        TypeVar: type_vars_factory,  # type: ignore[dict-item]
+        Callable: pure_functions_factory,  # type: ignore[dict-item]
+        **{
+            interface: _strategy_for_container(container_type, settings)
+            for interface in container_type.laws()
+        },
+        container_type: _strategy_for_container(container_type, settings),
+    }
 
 
 def _strategy_for_container(

tests/test_contrib/test_hypothesis/test_type_resolution.py

@@ -1,5 +1,4 @@
 from collections.abc import Callable, Sequence
-from contextlib import ExitStack
 from typing import Any, TypeVar
 
 import pytest
@@ -17,8 +16,8 @@
     RequiresContextResultE,
 )
 from returns.contrib.hypothesis.laws import (
-    _enter_hypothesis_context,  # noqa: PLC2701
     _Settings,  # noqa: PLC2701
+    _types_to_strategies,  # noqa: PLC2701
 )
 from returns.contrib.hypothesis.type_resolver import (
     StrategyFactory,
@@ -116,134 +115,95 @@ def test_custom_readerresult_types_resolve(
 _ValueType = TypeVar('_ValueType')
 
 
-def test_hypothesis_state_outside_context() -> None:  # noqa: WPS210
-    """Check values of strategies before we register them.
-
-    This is mostly useful as a baseline to compare the the values when we do
-    register them.
-    """
+def test_types_to_strategies_default() -> None:  # noqa: WPS210
+    """Check the default strategies for types."""
     container_type = test_custom_type_applicative._Wrapper  # noqa: SLF001
     # NOTE: There is a type error because `Callable` is a
     # special form, not a type.
     callable_type: type[object] = Callable  # type: ignore[assignment]
 
-    container_strategy_outside = look_up_strategy(container_type)
-    interface_strategies_outside = _interface_factories(container_type)
-    pure_functions_strategy_outside = look_up_strategy(callable_type)
-    type_var_strategy_outside = look_up_strategy(TypeVar)
-
-    assert (
-        _strategy_string(container_strategy_outside, container_type) == 'None'
-    )
-    assert _strategy_strings(interface_strategies_outside, container_type) == [
-        'None',
-        'None',
-    ]
-    assert (
-        _strategy_string(
-            pure_functions_strategy_outside, Callable[[int, str], bool]
-        )
-        == 'functions(like=lambda *a, **k: None, returns=booleans())'
-    )
-    assert (
-        _strategy_string(type_var_strategy_outside, _ValueType)
-        == "shared(sampled_from([<class 'NoneType'>, <class 'bool'>,"
-        " <class 'int'>, <class 'float'>, <class 'str'>, <class 'bytes'>]),"
-        " key='typevar=~_ValueType').flatmap(from_type)"
+    result = _types_to_strategies(
+        container_type,
+        _Settings(
+            settings_kwargs={},
+            use_init=False,
+            container_strategy=None,
+        ),
     )
 
-
-def test_hypothesis_state_inside_context() -> None:  # noqa: WPS210
-    """Check that strategies are registered correctly."""
-    container_type = test_custom_type_applicative._Wrapper  # noqa: SLF001
-    # NOTE: There is a type error because `Callable` is a
-    # special form, not a type.
-    callable_type: type[object] = Callable  # type: ignore[assignment]
-
-    with ExitStack() as stack:
-        _enter_hypothesis_context(
-            stack,
-            container_type,
-            settings=_Settings(
-                settings_kwargs={}, use_init=False, container_strategy=None
-            ),
-        )
-        container_strategy = look_up_strategy(container_type)
-        interface_strategies = _interface_factories(container_type)
-        pure_functions_strategy = look_up_strategy(callable_type)
-        type_var_strategy = look_up_strategy(TypeVar)
-
     wrapper_strategy = (
         "builds(from_value, shared(sampled_from([<class 'NoneType'>,"
         " <class 'bool'>, <class 'int'>, <class 'float'>, <class 'str'>,"
         " <class 'bytes'>]), key='typevar=~_FirstType').flatmap(from_type))"
     )
     assert (
-        _strategy_string(container_strategy, container_type) == wrapper_strategy
+        _strategy_string(result[container_type], container_type)
+        == wrapper_strategy
     )
-    assert _strategy_strings(interface_strategies, container_type) == [
+    assert _strategy_strings(
+        [result[interface] for interface in container_type.laws()],
+        container_type,
+    ) == [
         wrapper_strategy,
         wrapper_strategy,
     ]
     assert (
-        _strategy_string(pure_functions_strategy, Callable[[int, str], bool])
+        _strategy_string(result[callable_type], Callable[[int, str], bool])
         == 'functions(like=lambda *args, **kwargs: <unknown>,'
         ' returns=booleans(), pure=True)'
     )
     assert (
-        _strategy_string(pure_functions_strategy, Callable[[], None])
+        _strategy_string(result[callable_type], Callable[[], None])
         == 'functions(like=lambda: None, returns=none(), pure=True)'
     )
     assert (
-        _strategy_string(type_var_strategy, _ValueType)
+        _strategy_string(result[TypeVar], _ValueType)
         == "shared(sampled_from([<class 'NoneType'>, <class 'bool'>,"
         " <class 'int'>, <class 'float'>, <class 'str'>, <class 'bytes'>]),"
         " key='typevar=~_ValueType').flatmap(from_type).filter(lambda"
         ' inner: inner == inner)'
     )
 
 
-def test_hypothesis_state_with_setting() -> None:  # noqa: WPS210
+def test_types_to_strategies_overrides() -> None:  # noqa: WPS210
     """Check that we prefer the strategies in settings."""
     container_type = test_custom_type_applicative._Wrapper  # noqa: SLF001
     # NOTE: There is a type error because `Callable` is a
     # special form, not a type.
     callable_type: type[object] = Callable  # type: ignore[assignment]
 
-    with ExitStack() as stack:
-        _enter_hypothesis_context(
-            stack,
-            container_type,
-            settings=_Settings(
-                settings_kwargs={},
-                use_init=False,
-                container_strategy=st.builds(container_type, st.integers()),
-            ),
-        )
-        container_strategy = look_up_strategy(container_type)
-        interface_strategies = _interface_factories(container_type)
-        pure_functions_strategy = look_up_strategy(callable_type)
-        type_var_strategy = look_up_strategy(TypeVar)
+    result = _types_to_strategies(
+        container_type,
+        _Settings(
+            settings_kwargs={},
+            use_init=False,
+            container_strategy=st.builds(container_type, st.integers()),
+        ),
+    )
 
     wrapper_strategy = 'builds(_Wrapper, integers())'
     assert (
-        _strategy_string(container_strategy, container_type) == wrapper_strategy
+        _strategy_string(result[container_type], container_type)
+        == wrapper_strategy
     )
-    assert _strategy_strings(interface_strategies, container_type) == [
+    assert _strategy_strings(
+        [result[interface] for interface in container_type.laws()],
+        container_type,
+    ) == [
         wrapper_strategy,
         wrapper_strategy,
     ]
     assert (
-        _strategy_string(pure_functions_strategy, Callable[[int, str], bool])
+        _strategy_string(result[callable_type], Callable[[int, str], bool])
         == 'functions(like=lambda *args, **kwargs: <unknown>,'
         ' returns=booleans(), pure=True)'
     )
     assert (
-        _strategy_string(pure_functions_strategy, Callable[[], None])
+        _strategy_string(result[callable_type], Callable[[], None])
         == 'functions(like=lambda: None, returns=none(), pure=True)'
     )
     assert (
-        _strategy_string(type_var_strategy, _ValueType)
+        _strategy_string(result[TypeVar], _ValueType)
         == "shared(sampled_from([<class 'NoneType'>, <class 'bool'>,"
         " <class 'int'>, <class 'float'>, <class 'str'>, <class 'bytes'>]),"
         " key='typevar=~_ValueType').flatmap(from_type).filter(lambda"