no cache fixtures POC

Author: niroshaimos

src/_pytest/fixtures.py

@@ -534,6 +534,12 @@ def getfixturevalue(self, argname: str) -> Any:
             f'The fixture value for "{argname}" is not available.  '
             "This can happen when the fixture has already been torn down."
         )
+
+        if (isinstance(fixturedef, FixtureDef)
+                and fixturedef is not None
+                and fixturedef.use_cache is False):
+            self._fixture_defs.pop(argname)
+
         return fixturedef.cached_result[0]
 
     def _iter_chain(self) -> Iterator[SubRequest]:
@@ -614,9 +620,15 @@ def _get_active_fixturedef(
         )
 
         # Make sure the fixture value is cached, running it if it isn't
-        fixturedef.execute(request=subrequest)
+        try:
+            fixturedef.execute(request=subrequest)
+            self._fixture_defs[argname] = fixturedef
+        finally:
+            for arg_name in fixturedef.argnames:
+                arg_fixture = self._fixture_defs.get(arg_name)
+                if arg_fixture is not None and arg_fixture.use_cache is not True:
+                    self._fixture_defs.pop(arg_name)
 
-        self._fixture_defs[argname] = fixturedef
         return fixturedef
 
     def _check_fixturedef_without_param(self, fixturedef: FixtureDef[object]) -> None:
@@ -957,6 +969,7 @@ def __init__(
         scope: Scope | _ScopeName | Callable[[str, Config], _ScopeName] | None,
         params: Sequence[object] | None,
         ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
+        use_cache: bool = True,
         *,
         _ispytest: bool = False,
     ) -> None:
@@ -1004,6 +1017,7 @@ def __init__(
         # Can change if the fixture is executed with different parameters.
         self.cached_result: _FixtureCachedResult[FixtureValue] | None = None
         self._finalizers: Final[list[Callable[[], object]]] = []
+        self.use_cache = use_cache
 
     @property
     def scope(self) -> _ScopeName:
@@ -1054,7 +1068,7 @@ def execute(self, request: SubRequest) -> FixtureValue:
                 requested_fixtures_that_should_finalize_us.append(fixturedef)
 
         # Check for (and return) cached value/exception.
-        if self.cached_result is not None:
+        if self.cached_result is not None and self.use_cache:
             request_cache_key = self.cache_key(request)
             cache_key = self.cached_result[1]
             try:
@@ -1183,6 +1197,7 @@ class FixtureFunctionMarker:
     autouse: bool = False
     ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None
     name: str | None = None
+    cache_result: bool = True
 
     _ispytest: dataclasses.InitVar[bool] = False
 
@@ -1225,6 +1240,7 @@ def fixture(
     autouse: bool = ...,
     ids: Sequence[object | None] | Callable[[Any], object | None] | None = ...,
     name: str | None = ...,
+    cache_result: bool = True,
 ) -> FixtureFunction: ...
 
 
@@ -1237,6 +1253,7 @@ def fixture(
     autouse: bool = ...,
     ids: Sequence[object | None] | Callable[[Any], object | None] | None = ...,
     name: str | None = None,
+    cache_result: bool = True,
 ) -> FixtureFunctionMarker: ...
 
 
@@ -1248,6 +1265,7 @@ def fixture(
     autouse: bool = False,
     ids: Sequence[object | None] | Callable[[Any], object | None] | None = None,
     name: str | None = None,
+    cache_result: bool = True,
 ) -> FixtureFunctionMarker | FixtureFunction:
     """Decorator to mark a fixture factory function.
 
@@ -1298,6 +1316,11 @@ def fixture(
         function arg that requests the fixture; one way to resolve this is to
         name the decorated function ``fixture_<fixturename>`` and then use
         ``@pytest.fixture(name='<fixturename>')``.
+
+    :param cache_result:
+        If True (the default), the fixture result is cached and the fixture
+        only runs once per scope.
+        If False, the fixture will run each time it is requested
     """
     fixture_marker = FixtureFunctionMarker(
         scope=scope,
@@ -1306,6 +1329,7 @@ def fixture(
         ids=None if ids is None else ids if callable(ids) else tuple(ids),
         name=name,
         _ispytest=True,
+        cache_result=cache_result
     )
 
     # Direct decoration.
@@ -1636,6 +1660,7 @@ def _register_fixture(
         params: Sequence[object] | None = None,
         ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
         autouse: bool = False,
+        cache_result: bool = True,
     ) -> None:
         """Register a fixture
 
@@ -1666,6 +1691,7 @@ def _register_fixture(
             params=params,
             ids=ids,
             _ispytest=True,
+            use_cache=cache_result,
         )
 
         faclist = self._arg2fixturedefs.setdefault(name, [])
@@ -1762,6 +1788,7 @@ def parsefactories(
                 params=marker.params,
                 ids=marker.ids,
                 autouse=marker.autouse,
+                cache_result=marker.cache_result
             )
 
     def getfixturedefs(

testing/test_no_cache.py

@@ -0,0 +1,108 @@
+from _pytest.pytester import Pytester
+
+
+def test_setup_teardown_executed_for_every_fixture_usage_without_caching(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        """
+        import pytest
+        import logging
+
+        @pytest.fixture(cache_result=False)
+        def fixt():
+            logging.info("&&Setting up fixt&&")
+            yield
+            logging.info("&&Tearing down fixt&&")
+
+
+        @pytest.fixture()
+        def a(fixt):
+            ...
+
+
+        @pytest.fixture()
+        def b(fixt):
+            ...
+
+
+        def test(a, b, fixt):
+            assert False
+    """)
+
+    result = pytester.runpytest("--log-level=INFO")
+    assert result.ret == 1
+    result.stdout.fnmatch_lines([
+        *["*&&Setting up fixt&&*"] * 3,
+        *["*&&Tearing down fixt&&*"] * 3,
+    ])
+
+
+def test_setup_teardown_executed_for_every_getfixturevalue_usage_without_caching(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        """
+        import pytest
+        import logging
+
+        @pytest.fixture(cache_result=False)
+        def fixt():
+            logging.info("&&Setting up fixt&&")
+            yield
+            logging.info("&&Tearing down fixt&&")
+
+
+        def test(request):
+            random_nums = [request.getfixturevalue('fixt') for _ in range(3)]
+            assert False
+    """
+    )
+    result = pytester.runpytest("--log-level=INFO")
+    assert result.ret == 1
+    result.stdout.fnmatch_lines([
+        *["*&&Setting up fixt&&*"] * 3,
+        *["*&&Tearing down fixt&&*"] * 3,
+    ])
+
+
+def test_non_cached_fixture_generates_unique_values_per_usage(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        """
+        import pytest
+
+        @pytest.fixture(cache_result=False)
+        def random_num():
+            import random
+            return random.randint(-100_000_000_000, 100_000_000_000)
+        
+        
+        @pytest.fixture()
+        def a(random_num):
+            return random_num
+        
+        
+        @pytest.fixture()
+        def b(random_num):
+            return random_num
+        
+        
+        def test(a, b, random_num):
+            assert a != b != random_num
+    """)
+    pytester.runpytest().assert_outcomes(passed=1)
+
+
+def test_non_cached_fixture_generates_unique_values_per_getfixturevalue_usage(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        """
+        import pytest
+
+        @pytest.fixture(cache_result=False)
+        def random_num():
+            import random
+            yield random.randint(-100_000_000_000, 100_000_000_000)
+        
+        
+        def test(request):
+            random_nums = [request.getfixturevalue('random_num') for _ in range(3)]
+            assert random_nums[0] != random_nums[1] != random_nums[2]
+    """
+    )
+    pytester.runpytest().assert_outcomes(passed=1)