hypothesis: split settings into default and override.

Author: pradeep90

returns/contrib/hypothesis/laws.py

@@ -1,6 +1,6 @@
 import dataclasses
 import inspect
-from collections.abc import Callable, Iterator, Mapping
+from collections.abc import Callable, Iterator
 from contextlib import ExitStack, contextmanager
 from typing import Any, TypeVar, final, overload
 
@@ -9,6 +9,7 @@
 from hypothesis import settings as hypothesis_settings
 from hypothesis import strategies as st
 from hypothesis.strategies._internal import types  # noqa: PLC2701
+from typing_extensions import Self
 
 from returns.contrib.hypothesis.containers import strategy_from_container
 from returns.contrib.hypothesis.type_resolver import (
@@ -28,6 +29,19 @@ class _Settings:
     settings_kwargs: dict[str, Any]
     use_init: bool
     container_strategy: StrategyFactory | None
+    other_strategies: dict[type[object], StrategyFactory] = dataclasses.field(
+        default_factory=dict
+    )
+
+    def __or__(self, other: Self) -> Self:
+        return _Settings(
+            settings_kwargs=self.settings_kwargs | other.settings_kwargs,
+            use_init=self.use_init | other.use_init,
+            container_strategy=self.container_strategy
+            if other.container_strategy is None
+            else other.container_strategy,
+            other_strategies=self.other_strategies | other.other_strategies,
+        )
 
     def __post_init__(self) -> None:
         """Check that the settings are mutually compatible."""
@@ -38,6 +52,23 @@ def __post_init__(self) -> None:
             )
 
 
+def _default_settings(container_type: type[Lawful]) -> _Settings:
+    """Return default settings for creating law tests.
+
+    We use special strategies for `TypeVar` and `Callable` by default, but
+    they can be overriden by the user if needed.
+    """
+    return _Settings(
+        settings_kwargs={},
+        use_init=False,
+        container_strategy=None,
+        other_strategies={
+            TypeVar: type_vars_factory,  # type: ignore[dict-item]
+            Callable: pure_functions_factory,  # type: ignore[dict-item]
+        },
+    )
+
+
 @overload
 def check_all_laws(
     container_type: type[Lawful[Example_co]],
@@ -222,15 +253,26 @@ def factory(source: st.DataObject) -> None:
 def _types_to_strategies(
     container_type: type[Lawful],
     settings: _Settings,
-) -> Mapping[type[object], StrategyFactory]:
+) -> dict[type[object], StrategyFactory]:
+    """Return a mapping from type to `hypothesis` strategy.
+
+    We override the default settings with the user-provided `settings`.
+    """
+    merged_settings = _default_settings(container_type) | settings
+    return merged_settings.other_strategies | _container_mapping(
+        container_type, merged_settings
+    )
+
+
+def _container_mapping(
+    container_type: type[Lawful],
+    settings: _Settings,
+) -> dict[type[object], StrategyFactory]:
+    """Map `container_type` and its interfaces to the container strategy."""
+    container_strategy = _strategy_for_container(container_type, settings)
     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),
+        **dict.fromkeys(container_type.laws(), container_strategy),
+        container_type: container_strategy,
     }
 
 

tests/test_contrib/test_hypothesis/test_type_resolution.py

@@ -25,6 +25,7 @@
     look_up_strategy,
 )
 from returns.future import Future, FutureResult
+from returns.interfaces.applicative import ApplicativeN
 from returns.io import IO, IOResult, IOResultE
 from returns.maybe import Maybe
 from returns.pipeline import is_successful
@@ -112,6 +113,64 @@ def test_custom_readerresult_types_resolve(
         assert isinstance(real_result.failure(), str)
 
 
+def test_merge_settings() -> None:
+    """Check that each part of the settings can be overridden by users."""
+    settings1 = _Settings(
+        settings_kwargs={'a': 1, 'b': 2},
+        use_init=False,
+        container_strategy=st.integers(),
+        other_strategies={int: st.integers(max_value=10), str: st.text('abc')},
+    )
+    settings2 = _Settings(
+        settings_kwargs={'a': 1, 'c': 3},
+        use_init=False,
+        container_strategy=st.integers(max_value=20),
+        other_strategies={int: st.integers(max_value=30), bool: st.booleans()},
+    )
+
+    result = settings1 | settings2
+
+    assert result == _Settings(
+        settings_kwargs={'a': 1, 'b': 2, 'c': 3},
+        use_init=False,
+        container_strategy=st.integers(max_value=20),
+        other_strategies={
+            int: st.integers(max_value=30),
+            bool: st.booleans(),
+            str: st.text('abc'),
+        },
+    )
+
+
+def test_merge_use_init() -> None:
+    """Check that `use_init` can be set to `True` by users.
+
+    Note: They can't set a `True` to `False`, since we use `|` to merge.
+    However, the default value is `False`, so this should not be a problem.
+    """
+    settings1 = _Settings(
+        settings_kwargs={},
+        use_init=False,
+        container_strategy=None,
+        other_strategies={},
+    )
+    settings2 = _Settings(
+        settings_kwargs={},
+        use_init=True,
+        container_strategy=None,
+        other_strategies={},
+    )
+
+    result = settings1 | settings2
+
+    assert result == _Settings(
+        settings_kwargs={},
+        use_init=True,
+        container_strategy=None,
+        other_strategies={},
+    )
+
+
 _ValueType = TypeVar('_ValueType')
 
 
@@ -166,7 +225,7 @@ def test_types_to_strategies_default() -> None:  # noqa: WPS210
 
 
 def test_types_to_strategies_overrides() -> None:  # noqa: WPS210
-    """Check that we prefer the strategies in settings."""
+    """Check that we allow the user to override all strategies."""
     container_type = test_custom_type_applicative._Wrapper  # noqa: SLF001
     # NOTE: There is a type error because `Callable` is a
     # special form, not a type.
@@ -178,6 +237,14 @@ def test_types_to_strategies_overrides() -> None:  # noqa: WPS210
             settings_kwargs={},
             use_init=False,
             container_strategy=st.builds(container_type, st.integers()),
+            other_strategies={
+                TypeVar: st.text(),
+                callable_type: st.functions(returns=st.booleans()),
+                # This strategy does not get used, because we use
+                # the given `container_strategy` for all interfaces of the
+                # container type.
+                ApplicativeN: st.tuples(st.integers()),
+            },
         ),
     )
 
@@ -195,20 +262,13 @@ def test_types_to_strategies_overrides() -> None:  # noqa: WPS210
     ]
     assert (
         _strategy_string(result[callable_type], Callable[[int, str], bool])
-        == 'functions(like=lambda *args, **kwargs: <unknown>,'
-        ' returns=booleans(), pure=True)'
+        == 'functions(returns=booleans())'
     )
     assert (
         _strategy_string(result[callable_type], Callable[[], None])
-        == 'functions(like=lambda: None, returns=none(), pure=True)'
-    )
-    assert (
-        _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)'
+        == 'functions(returns=booleans())'
     )
+    assert _strategy_string(result[TypeVar], _ValueType) == 'text()'
 
 
 def _interface_factories(type_: type[Lawful]) -> list[StrategyFactory | None]: