is_lazy is now part of public API, and _LazyValue now has a cache mechanism like _LazyTuple. Fixes #143

Author: Sylvain MARIE

pytest_cases/__init__.py

@@ -2,7 +2,7 @@
 #          + All contributors to <https://github.com/smarie/python-pytest-cases>
 #
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
-from .common_pytest_lazy_values import lazy_value
+from .common_pytest_lazy_values import lazy_value, is_lazy
 from .common_others import unfold_expected_err, assert_exception, AUTO, AUTO2
 
 from .fixture_core1_unions import fixture_union, NOT_USED, unpack_fixture, ignore_unused
@@ -46,7 +46,7 @@
     # -- fixture core2
     'pytest_fixture_plus', 'fixture_plus', 'fixture', 'param_fixtures', 'param_fixture',
     # -- fixture parametrize plus
-    'pytest_parametrize_plus', 'parametrize_plus', 'parametrize', 'fixture_ref', 'lazy_value',
+    'pytest_parametrize_plus', 'parametrize_plus', 'parametrize', 'fixture_ref', 'lazy_value', 'is_lazy',
 
     # V1 - DEPRECATED symbols
     # --cases_funcs

pytest_cases/common_pytest_lazy_values.py

@@ -125,19 +125,24 @@ class _LazyValue(Lazy):
     fixture and therefore can neither be parametrized nor depend on fixtures. It should have no mandatory argument.
     """
     if pytest53:
-        __slots__ = 'valuegetter', '_id', '_marks'
+        __slots__ = 'valuegetter', '_id', '_marks', 'retrieved', 'value'
         _field_names = __slots__
     else:
-        # we can not define __slots__ since we extend int,
+        # we can not define __slots__ since we'll extend int in a subclass
         # see https://docs.python.org/3/reference/datamodel.html?highlight=__slots__#notes-on-using-slots
-        _field_names = 'valuegetter', '_id', '_marks'
+        _field_names = 'valuegetter', '_id', '_marks', 'retrieved', 'value'
 
     @classmethod
     def copy_from(cls,
                   obj  # type: _LazyValue
                   ):
         """Creates a copy of this _LazyValue"""
-        return cls(valuegetter=obj.valuegetter, id=obj._id, marks=obj._marks)
+        new_obj = cls(valuegetter=obj.valuegetter, id=obj._id, marks=obj._marks)
+        # make sure the copy will not need to retrieve the result if already done
+        new_obj.retrieved = obj.retrieved
+        if new_obj.retrieved:
+            new_obj.value = obj.value
+        return new_obj
 
     # noinspection PyMissingConstructor
     def __init__(self,
@@ -151,6 +156,8 @@ def __init__(self,
             self._marks = marks
         else:
             self._marks = (marks, )
+        self.retrieved = False
+        self.value = None
 
     def get_marks(self, as_decorators=False):
         """
@@ -186,13 +193,24 @@ def get_id(self):
                 return vg.__name__
 
     def get(self):
-        return self.valuegetter()
+        """ Call the underlying value getter, then return the result value (not self). With a cache mechanism """
+        if not self.retrieved:
+            # retrieve
+            self.value = self.valuegetter()
+            self.retrieved = True
+
+        return self.value
 
     def as_lazy_tuple(self, nb_params):
-        return LazyTuple(self, nb_params)
+        res = LazyTuple(self, nb_params)
+        if self.retrieved:
+            # make sure the tuple will not need to retrieve the result if already done
+            res.retrieved = True
+            res.value = self.value
+        return res
 
     def as_lazy_items_list(self, nb_params):
-        return [v for v in LazyTuple(self, nb_params)]
+        return [v for v in self.as_lazy_tuple(nb_params)]
 
 
 class _LazyTupleItem(Lazy):
@@ -203,7 +221,7 @@ class _LazyTupleItem(Lazy):
         __slots__ = 'host', 'item'
         _field_names = __slots__
     else:
-        # we can not define __slots__ since we extend int,
+        # we can not define __slots__ since we'll extend int in a subclass
         # see https://docs.python.org/3/reference/datamodel.html?highlight=__slots__#notes-on-using-slots
         _field_names = 'host', 'item'
 
@@ -258,6 +276,7 @@ def copy_from(cls,
                   obj  # type: LazyTuple
                   ):
         new_obj = cls(valueref=obj.value, theoretical_size=obj.theoretical_size)
+        # make sure the copy will not need to retrieve the result if already done
         new_obj.retrieved = obj.retrieved
         if new_obj.retrieved:
             new_obj.value = obj.value
@@ -281,7 +300,7 @@ def get_id(self):
         return self.valuegetter.get_id()
 
     def get(self):
-        """ Call the underlying value getter, then return the tuple (not self) """
+        """ Call the underlying value getter, then return the result tuple (not self). With a cache mechanism """
         if not self.retrieved:
             # retrieve
             self.value = self.valuegetter.get()

pytest_cases/tests/pytest_extension/parametrize_plus/test_lazy_value_low_level.py

@@ -5,19 +5,27 @@
 from distutils.version import LooseVersion
 
 import pytest
+from pytest_cases.common_pytest_lazy_values import LazyValue, LazyTuple
 
 from pytest_cases import lazy_value
 from pytest_cases.common_pytest import mini_idval
 
 
+_called = 0
+
+
 def test_value_ref():
     """
     Tests that our hack for lazy_value works: for old versions of pytest, we make it a subclass
     of int so that pytest id generator (`_idval`) calls "str" on it. For pytest >= 5.3.0 we do not need this hack
     as overriding __name__ is enough.
     :return:
     """
+    global _called
+
     def foo():
+        global _called
+        _called += 1
         return 1, 2
 
     a = lazy_value(foo)
@@ -26,25 +34,45 @@ def foo():
     assert mini_idval(a, 'a', 1) == 'foo'
     assert 'LazyValue' in repr(a)
 
+    # test that that calls work and the cache works even across copies
+    assert a.get() == (1, 2)
+    assert a.get() == (1, 2)
+    assert LazyValue.copy_from(a).get() == (1, 2)
+    assert _called == 1
+
     # now do the same test for lazy values used as a tuple of parameters
-    at = lazy_value(foo).as_lazy_tuple(2)
-
-    # test when the tuple is unpacked into several parameters
-    for i, a in enumerate(at):
-        # 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)
-
-    # test when the tuple is not unpacked -
-    # note: this is not supposed to happen when @parametrize decorates a test function,
-    # it only happens when @parametrize decorates a fixture - indeed in that case we generate the whole id ourselves
-    assert str(at) == 'foo'
-    assert not at.retrieved
-    # test that retrieving the tuple does not loose the id
-    v = at.get()
-    assert v == (1, 2)
-    assert str(at) == 'foo'
-    assert at.retrieved
+    new_lv = lazy_value(foo)
+    assert not new_lv.retrieved
+    assert a.retrieved
+
+    for src in new_lv, a:
+        _called = 0 if not src.retrieved else 1
+        at = src.as_lazy_tuple(2)
+
+        # test when the tuple is unpacked into several parameters
+        if not at.retrieved:
+            for i, a in enumerate(at):
+                # 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)
+        else:
+            # this does not happen in real usage but in case a plugin messes with this
+            assert tuple(at) == (1, 2)
+
+        # test when the tuple is not unpacked -
+        # note: this is not supposed to happen when @parametrize decorates a test function,
+        # it only happens when @parametrize decorates a fixture - indeed in that case we generate the whole id ourselves
+        assert str(at) == 'foo'
+
+        # assert that calls work and the cache works even across copies
+        assert at.get() == (1, 2)
+        assert at.get() == (1, 2)
+        assert LazyTuple.copy_from(at).get() == (1, 2)
+        assert _called == 1
+
+        # test that retrieving the tuple does not loose the id
+        assert str(at) == 'foo'
+        assert at.retrieved
 
 
 pytest53 = LooseVersion(pytest.__version__) >= LooseVersion("5.3.0")