laws: restrict interface-patching to interfaces with laws.

We check that the interface class actually has laws. This should
eliminate any false positives that come from patching interfaces that
were defined outside `returns`.

Added a `_ParentWrapper` to test that it doesn't show up. (It did before
the change in this commit.)

Add to CHANGELOG and the hypothesis plugins page.

Author: pradeep90

CHANGELOG.md

@@ -24,6 +24,10 @@ See [0Ver](https://0ver.org/).
 
 ## 0.24.1
 
+### Features
+
+- Make `hypothesis` plugin test laws from user-defined interfaces too
+
 ### Bugfixes
 
 - Add pickling support for `UnwrapFailedError` exception

docs/pages/contrib/hypothesis_plugins.rst

@@ -81,9 +81,9 @@ It works in a combination with "Laws as Values" feature we provide in the core.
 
   check_all_laws(YourCustomContainer)
 
-This one line of code will generate ~100 tests for all defined law
+This one line of code will generate ~100 tests for all defined laws
 in both ``YourCustomContainer`` and all its super types,
-including our internal ones.
+including our internal ones and user-defined ones.
 
 We also provide a way to configure
 the checking process with ``settings_kwargs``:

returns/contrib/hypothesis/laws.py

@@ -10,7 +10,7 @@
 from hypothesis.strategies._internal import types  # noqa: PLC2701
 
 from returns.contrib.hypothesis.containers import strategy_from_container
-from returns.primitives.laws import Law, Lawful
+from returns.primitives.laws import LAWS_ATTRIBUTE, Law, Lawful
 
 
 @final
@@ -214,7 +214,7 @@ def clean_plugin_context() -> Iterator[None]:
             st.register_type_strategy(*saved_state)
 
 
-def lawful_interfaces(container_type: type[Lawful]) -> set[type[object]]:
+def lawful_interfaces(container_type: type[Lawful]) -> set[type[Lawful]]:
     """Return ancestors of `container_type` that are lawful interfaces."""
     return {
         base_type
@@ -227,7 +227,13 @@ def lawful_interfaces(container_type: type[Lawful]) -> set[type[object]]:
 def _is_lawful_interface(
     interface_type: type[object],
 ) -> TypeGuard[type[Lawful]]:
-    return issubclass(interface_type, Lawful)
+    return issubclass(interface_type, Lawful) and _has_non_inherited_attribute(
+        interface_type, LAWS_ATTRIBUTE
+    )
+
+
+def _has_non_inherited_attribute(type_: type[object], attribute: str) -> bool:
+    return attribute in type_.__dict__
 
 
 def _clean_caches() -> None:

returns/primitives/laws.py

@@ -12,6 +12,8 @@
 #: Special alias to define laws as functions even inside a class
 law_definition = staticmethod
 
+LAWS_ATTRIBUTE: str = '_laws'
+
 
 class Law(Immutable):
     """
@@ -132,7 +134,7 @@ def laws(cls) -> dict[type['Lawful'], Sequence[Law]]:  # noqa: WPS210
 
         laws = {}
         for klass in seen.values():
-            current_laws = klass.__dict__.get('_laws', ())
+            current_laws = klass.__dict__.get(LAWS_ATTRIBUTE, ())
             if not current_laws:
                 continue
             laws[klass] = current_laws

tests/test_contrib/test_hypothesis/test_interface_resolution.py

@@ -14,15 +14,11 @@ def test_lawful_interfaces__container_defined_in_returns() -> None:
     assert sorted(str(interface) for interface in result) == [
         "<class 'returns.interfaces.altable.AltableN'>",
         "<class 'returns.interfaces.applicative.ApplicativeN'>",
-        "<class 'returns.interfaces.bimappable.BiMappableN'>",
         "<class 'returns.interfaces.container.ContainerN'>",
         "<class 'returns.interfaces.equable.Equable'>",
         "<class 'returns.interfaces.failable.DiverseFailableN'>",
         "<class 'returns.interfaces.failable.FailableN'>",
         "<class 'returns.interfaces.mappable.MappableN'>",
-        "<class 'returns.interfaces.specific.result.ResultBasedN'>",
-        "<class 'returns.interfaces.specific.result.ResultLikeN'>",
-        "<class 'returns.interfaces.specific.result.UnwrappableResult'>",
         "<class 'returns.interfaces.swappable.SwappableN'>",
     ]
 

tests/test_contrib/test_hypothesis/test_laws/test_custom_interface_with_laws.py

@@ -2,8 +2,6 @@
 from collections.abc import Callable, Sequence
 from typing import ClassVar, Generic, TypeAlias, TypeVar, final
 
-import pytest
-from hypothesis.errors import ResolutionFailed
 from typing_extensions import Never
 
 from returns.contrib.hypothesis.laws import check_all_laws
@@ -84,10 +82,14 @@ def map(
 _Mappable1: TypeAlias = _MappableN[_FirstType, Never, Never]
 
 
+class _ParentWrapper(_Mappable1[_ValueType]):
+    """Class that is an ancestor of `_Wrapper` but has no laws."""
+
+
 class _Wrapper(
     BaseContainer,
     SupportsKind1['_Wrapper', _ValueType],
-    _Mappable1[_ValueType],
+    _ParentWrapper[_ValueType],
 ):
     """Simple instance of `_MappableN`."""
 
@@ -103,6 +105,6 @@ def map(
         return _Wrapper(function(self._inner_value))
 
 
-pytestmark = pytest.mark.xfail(raises=ResolutionFailed)
-
-check_all_laws(_Wrapper)
+# We need to use `use_init=True` because `MappableN` does not automatically
+# get a strategy from `strategy_from_container`.
+check_all_laws(_Wrapper, use_init=True)