LazyValue, LazyTuple and LazyTupleItem are now hashable. This increases compatibility with plugins hashing the parameter values, such as pytest-steps. See smarie/python-pytest-steps#41 . Fixes #199

Author: Sylvain MARIE

pytest_cases/common_pytest_lazy_values.py

@@ -164,6 +164,10 @@ def __init__(self,
         self.cached_value_context = None
         self.cached_value = None
 
+    def __hash__(self):
+        """Provide a minimal hash representing the class, valuegetter, id and marks"""
+        return hash((self.__class__, self.valuegetter, self._id, self._marks))
+
     def get_marks(self,
                   as_decorators=False  # type: bool
                   ):
@@ -268,6 +272,10 @@ def __init__(self,
         self.host = host
         self.item = item
 
+    def __hash__(self):
+        """Provide a minimal hash representing the class, host and item number"""
+        return hash((self.__class__, self.host, self.item))
+
     def __repr__(self):
         """Override the inherited method to avoid infinite recursion"""
         vals_to_display = (
@@ -321,6 +329,10 @@ def __init__(self,
         self._lazyvalue = valueref
         self.theoretical_size = theoretical_size
 
+    def __hash__(self):
+        """Provide a minimal hash representing the class, lazy value, and theoretical size"""
+        return hash((self.__class__, self._lazyvalue, self.theoretical_size))
+
     def __len__(self):
         return self.theoretical_size
 

pytest_cases/tests/pytest_extension/issues/test_issue_199.py

@@ -0,0 +1,53 @@
+from pytest_steps import test_steps
+
+from pytest_cases import parametrize, fixture, lazy_value
+
+
+@fixture
+def fix():
+    return 1
+
+
+@fixture
+def fixtuple():
+    return 1, 2
+
+
+def foo():
+    return 2
+
+
+def footuple():
+    return 3, 4
+
+
+@test_steps("step1", "step2")
+@parametrize("b,c", [fixtuple, lazy_value(footuple)])
+@parametrize(a=[fix, lazy_value(foo)])
+def test_steps_and_cases(a, b, c):
+
+    print("step 1")
+    assert a in (1, 2)
+    assert (b, c) in ((1, 2), (3, 4))
+    yield
+
+    print("step 2")
+    assert a in (1, 2)
+    assert (b, c) in ((1, 2), (3, 4))
+    yield
+
+
+@test_steps("step1", "step2")
+@parametrize("b,c", [lazy_value(footuple)])  # no fixture ref: only lazy
+@parametrize(a=[lazy_value(foo)])            # no fixture ref: only lazy
+def test_steps_and_cases2(a, b, c):
+
+    print("step 1")
+    assert a in (1, 2)
+    assert (b, c) in ((1, 2), (3, 4))
+    yield
+
+    print("step 2")
+    assert a in (1, 2)
+    assert (b, c) in ((1, 2), (3, 4))
+    yield

pytest_cases/tests/pytest_extension/parametrize_plus/test_lazy_value_low_level.py

@@ -5,7 +5,7 @@
 import pytest
 
 from pytest_cases.common_pytest_marks import PYTEST53_OR_GREATER
-from pytest_cases.common_pytest_lazy_values import LazyValue, LazyTuple
+from pytest_cases.common_pytest_lazy_values import LazyValue, LazyTuple, LazyTupleItem
 
 from pytest_cases import lazy_value
 from pytest_cases.common_pytest import mini_idval
@@ -30,6 +30,9 @@ def foo():
 
     a = lazy_value(foo)
 
+    # test that it is hashable
+    assert hash(a) == hash((LazyValue, foo, None, ()))
+
     # test that ids will be correctly generated even on old pytest
     assert mini_idval(a, 'a', 1) == 'foo'
     assert 'LazyValue' in repr(a)
@@ -67,9 +70,15 @@ def __init__(self):
         _called = 0 if not src.has_cached_value() else 1
         at = src.as_lazy_tuple(2)
 
+        # test that it is hashable
+        assert hash(at) == hash((LazyTuple, src, 2))
+
         # test when the tuple is unpacked into several parameters
         if not at.has_cached_value():
             for i, a in enumerate(at):
+                # test that it is hashable
+                assert hash(a) == hash((LazyTupleItem, at, i))
+
                 # test that ids will be correctly generated even on old pytest
                 assert mini_idval(a, 'a', 1) == 'foo[%s]' % i
                 assert ('LazyTupleItem(item=%s' % i) in repr(a)