hypothesis: use the settings strategy for ancestor interfaces too.

Author: pradeep90

returns/contrib/hypothesis/laws.py

@@ -89,10 +89,7 @@ def interface_strategies(
     Can be used independently from other functions.
     """
     mapping: Mapping[type[object], StrategyFactory] = {
-        interface: strategy_from_container(
-            container_type,
-            use_init=settings.use_init,
-        )
+        interface: _strategy_for_container(container_type, settings)
         for interface in lawful_interfaces(container_type)
     }
     with strategies_for_types(mapping):
@@ -106,12 +103,9 @@ def register_container(
     settings: Settings,
 ) -> Iterator[None]:
     """Temporary registers a container if it is not registered yet."""
-    strategy = (
-        strategy_from_container(container_type, use_init=settings.use_init)
-        if settings.strategy is None
-        else settings.strategy
-    )
-    with strategies_for_types({container_type: strategy}):
+    with strategies_for_types({
+        container_type: _strategy_for_container(container_type, settings)
+    }):
         yield
 
 
@@ -228,6 +222,16 @@ def _clean_caches() -> None:
     st.from_type.__clear_cache()  # type: ignore[attr-defined]  # noqa: SLF001
 
 
+def _strategy_for_container(
+    container_type: type[Lawful], settings: Settings
+) -> StrategyFactory:
+    return (
+        strategy_from_container(container_type, use_init=settings.use_init)
+        if settings.strategy is None
+        else settings.strategy
+    )
+
+
 def _run_law(
     container_type: type[Lawful],
     law: Law,

tests/test_contrib/test_hypothesis/test_type_resolution.py

@@ -213,6 +213,38 @@ def test_interface_strategies() -> None:
     ]
 
 
+def test_interface_strategies_with_settings() -> None:
+    """Check that we prefer the strategy in the settings."""
+    container_type = test_custom_type_applicative._Wrapper  # noqa: SLF001
+
+    strategy_factories_before = _interface_factories(container_type)
+
+    with interface_strategies(
+        container_type,
+        settings=Settings(
+            settings_kwargs={},
+            use_init=False,
+            strategy=st.builds(container_type, st.integers()),
+        ),
+    ):
+        strategy_factories_inside = _interface_factories(container_type)
+
+    strategy_factories_after = _interface_factories(container_type)
+
+    assert _strategy_strings(strategy_factories_before, container_type) == [
+        'None',
+        'None',
+    ]
+    assert _strategy_strings(strategy_factories_inside, container_type) == [
+        'builds(_Wrapper, integers())',
+        'builds(_Wrapper, integers())',
+    ]
+    assert _strategy_strings(strategy_factories_after, container_type) == [
+        'None',
+        'None',
+    ]
+
+
 def _interface_factories(type_: type[Lawful]) -> list[StrategyFactory | None]:
     return [
         look_up_strategy(interface) for interface in lawful_interfaces(type_)