floraachy
/
pytest2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

python,unittest: replace obj fixture patching with `FixtureManager._register_fixture` 

Instead of modifying user objects like modules and classes that we
really shouldn't be touching, use the new `_register_fixture` internal
API to do it directly.
This commit is contained in:
Ran Benita 2024-01-04 23:51:58 +02:00
parent 3234c79ee5
commit c8792bd080
2 changed files with 91 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/_pytest/python.py
View File

@ -582,13 +582,13 @@ class Module(nodes.File, PyCollector):
return importtestmodule(self.path, self.config) return importtestmodule(self.path, self.config)
def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]: def collect(self) -> Iterable[Union[nodes.Item, nodes.Collector]]:
self._inject_setup_module_fixture() self._register_setup_module_fixture()
self._inject_setup_function_fixture() self._register_setup_function_fixture()
self.session._fixturemanager.parsefactories(self) self.session._fixturemanager.parsefactories(self)
return super().collect() return super().collect()
def _inject_setup_module_fixture(self) -> None: def _register_setup_module_fixture(self) -> None:
"""Inject a hidden autouse, module scoped fixture into the collected module object """Register an autouse, module-scoped fixture for the collected module object
that invokes setUpModule/tearDownModule if either or both are available. that invokes setUpModule/tearDownModule if either or both are available.
Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
@ -604,23 +604,25 @@ class Module(nodes.File, PyCollector):
if setup_module is None and teardown_module is None: if setup_module is None and teardown_module is None:
return return
@fixtures.fixture(
autouse=True,
scope="module",
# Use a unique name to speed up lookup.
name=f"_xunit_setup_module_fixture_{self.obj.__name__}",
)
def xunit_setup_module_fixture(request) -> Generator[None, None, None]: def xunit_setup_module_fixture(request) -> Generator[None, None, None]:
module = request.module
if setup_module is not None: if setup_module is not None:
_call_with_optional_argument(setup_module, request.module) _call_with_optional_argument(setup_module, module)
yield yield
if teardown_module is not None: if teardown_module is not None:
_call_with_optional_argument(teardown_module, request.module) _call_with_optional_argument(teardown_module, module)
self.obj.__pytest_setup_module = xunit_setup_module_fixture self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_xunit_setup_module_fixture_{self.obj.__name__}",
func=xunit_setup_module_fixture,
nodeid=self.nodeid,
scope="module",
autouse=True,
)
def _inject_setup_function_fixture(self) -> None: def _register_setup_function_fixture(self) -> None:
"""Inject a hidden autouse, function scoped fixture into the collected module object """Register an autouse, function-scoped fixture for the collected module object
that invokes setup_function/teardown_function if either or both are available. that invokes setup_function/teardown_function if either or both are available.
Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
@ -633,25 +635,27 @@ class Module(nodes.File, PyCollector):
if setup_function is None and teardown_function is None: if setup_function is None and teardown_function is None:
return return
@fixtures.fixture(
autouse=True,
scope="function",
# Use a unique name to speed up lookup.
name=f"_xunit_setup_function_fixture_{self.obj.__name__}",
)
def xunit_setup_function_fixture(request) -> Generator[None, None, None]: def xunit_setup_function_fixture(request) -> Generator[None, None, None]:
if request.instance is not None: if request.instance is not None:
# in this case we are bound to an instance, so we need to let # in this case we are bound to an instance, so we need to let
# setup_method handle this # setup_method handle this
yield yield
return return
function = request.function
if setup_function is not None: if setup_function is not None:
_call_with_optional_argument(setup_function, request.function) _call_with_optional_argument(setup_function, function)
yield yield
if teardown_function is not None: if teardown_function is not None:
_call_with_optional_argument(teardown_function, request.function) _call_with_optional_argument(teardown_function, function)
self.obj.__pytest_setup_function = xunit_setup_function_fixture self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_xunit_setup_function_fixture_{self.obj.__name__}",
func=xunit_setup_function_fixture,
nodeid=self.nodeid,
scope="function",
autouse=True,
)
class Package(nodes.Directory): class Package(nodes.Directory):
@ -795,15 +799,15 @@ class Class(PyCollector):
) )
return [] return []
self._inject_setup_class_fixture() self._register_setup_class_fixture()
self._inject_setup_method_fixture() self._register_setup_method_fixture()
self.session._fixturemanager.parsefactories(self.newinstance(), self.nodeid) self.session._fixturemanager.parsefactories(self.newinstance(), self.nodeid)
return super().collect() return super().collect()
def _inject_setup_class_fixture(self) -> None: def _register_setup_class_fixture(self) -> None:
"""Inject a hidden autouse, class scoped fixture into the collected class object """Register an autouse, class scoped fixture into the collected class object
that invokes setup_class/teardown_class if either or both are available. that invokes setup_class/teardown_class if either or both are available.
Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
@ -814,25 +818,27 @@ class Class(PyCollector):
if setup_class is None and teardown_class is None: if setup_class is None and teardown_class is None:
return return
@fixtures.fixture( def xunit_setup_class_fixture(request) -> Generator[None, None, None]:
autouse=True, cls = request.cls
scope="class",
# Use a unique name to speed up lookup.
name=f"_xunit_setup_class_fixture_{self.obj.__qualname__}",
)
def xunit_setup_class_fixture(cls) -> Generator[None, None, None]:
if setup_class is not None: if setup_class is not None:
func = getimfunc(setup_class) func = getimfunc(setup_class)
_call_with_optional_argument(func, self.obj) _call_with_optional_argument(func, cls)
yield yield
if teardown_class is not None: if teardown_class is not None:
func = getimfunc(teardown_class) func = getimfunc(teardown_class)
_call_with_optional_argument(func, self.obj) _call_with_optional_argument(func, cls)
self.obj.__pytest_setup_class = xunit_setup_class_fixture self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_xunit_setup_class_fixture_{self.obj.__qualname__}",
func=xunit_setup_class_fixture,
nodeid=self.nodeid,
scope="class",
autouse=True,
)
def _inject_setup_method_fixture(self) -> None: def _register_setup_method_fixture(self) -> None:
"""Inject a hidden autouse, function scoped fixture into the collected class object """Register an autouse, function scoped fixture into the collected class object
that invokes setup_method/teardown_method if either or both are available. that invokes setup_method/teardown_method if either or both are available.
Using a fixture to invoke these methods ensures we play nicely and unsurprisingly with Using a fixture to invoke these methods ensures we play nicely and unsurprisingly with
@ -845,23 +851,25 @@ class Class(PyCollector):
if setup_method is None and teardown_method is None: if setup_method is None and teardown_method is None:
return return
@fixtures.fixture( def xunit_setup_method_fixture(request) -> Generator[None, None, None]:
autouse=True, instance = request.instance
scope="function",
# Use a unique name to speed up lookup.
name=f"_xunit_setup_method_fixture_{self.obj.__qualname__}",
)
def xunit_setup_method_fixture(self, request) -> Generator[None, None, None]:
method = request.function method = request.function
if setup_method is not None: if setup_method is not None:
func = getattr(self, setup_name) func = getattr(instance, setup_name)
_call_with_optional_argument(func, method) _call_with_optional_argument(func, method)
yield yield
if teardown_method is not None: if teardown_method is not None:
func = getattr(self, teardown_name) func = getattr(instance, teardown_name)
_call_with_optional_argument(func, method) _call_with_optional_argument(func, method)
self.obj.__pytest_setup_method = xunit_setup_method_fixture self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_xunit_setup_method_fixture_{self.obj.__qualname__}",
func=xunit_setup_method_fixture,
nodeid=self.nodeid,
scope="function",
autouse=True,
)
def hasinit(obj: object) -> bool: def hasinit(obj: object) -> bool:

58
src/_pytest/unittest.py
View File

@ -70,9 +70,9 @@ class UnitTestCase(Class):
skipped = _is_skipped(cls) skipped = _is_skipped(cls)
if not skipped: if not skipped:
self._inject_unittest_setup_method_fixture(cls) self._register_unittest_setup_method_fixture(cls)
self._inject_unittest_setup_class_fixture(cls) self._register_unittest_setup_class_fixture(cls)
self._inject_setup_class_fixture() self._register_setup_class_fixture()
self.session._fixturemanager.parsefactories(self, unittest=True) self.session._fixturemanager.parsefactories(self, unittest=True)
loader = TestLoader() loader = TestLoader()
@ -93,8 +93,8 @@ class UnitTestCase(Class):
if ut is None or runtest != ut.TestCase.runTest: # type: ignore if ut is None or runtest != ut.TestCase.runTest: # type: ignore
yield TestCaseFunction.from_parent(self, name="runTest") yield TestCaseFunction.from_parent(self, name="runTest")
def _inject_unittest_setup_class_fixture(self, cls: type) -> None: def _register_unittest_setup_class_fixture(self, cls: type) -> None:
"""Injects a hidden auto-use fixture to invoke setUpClass and """Register an auto-use fixture to invoke setUpClass and
tearDownClass (#517).""" tearDownClass (#517)."""
setup = getattr(cls, "setUpClass", None) setup = getattr(cls, "setUpClass", None)
teardown = getattr(cls, "tearDownClass", None) teardown = getattr(cls, "tearDownClass", None)
@ -102,15 +102,12 @@ class UnitTestCase(Class):
return None return None
cleanup = getattr(cls, "doClassCleanups", lambda: None) cleanup = getattr(cls, "doClassCleanups", lambda: None)
@pytest.fixture( def unittest_setup_class_fixture(
scope="class", request: FixtureRequest,
autouse=True, ) -> Generator[None, None, None]:
# Use a unique name to speed up lookup. cls = request.cls
name=f"_unittest_setUpClass_fixture_{cls.__qualname__}", if _is_skipped(cls):
) reason = cls.__unittest_skip_why__
def fixture(self) -> Generator[None, None, None]:
if _is_skipped(self):
reason = self.__unittest_skip_why__
raise pytest.skip.Exception(reason, _use_item_location=True) raise pytest.skip.Exception(reason, _use_item_location=True)
if setup is not None: if setup is not None:
try: try:
@ -127,23 +124,27 @@ class UnitTestCase(Class):
finally: finally:
cleanup() cleanup()
cls.__pytest_class_setup = fixture # type: ignore[attr-defined] self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_unittest_setUpClass_fixture_{cls.__qualname__}",
func=unittest_setup_class_fixture,
nodeid=self.nodeid,
scope="class",
autouse=True,
)
def _inject_unittest_setup_method_fixture(self, cls: type) -> None: def _register_unittest_setup_method_fixture(self, cls: type) -> None:
"""Injects a hidden auto-use fixture to invoke setup_method and """Register an auto-use fixture to invoke setup_method and
teardown_method (#517).""" teardown_method (#517)."""
setup = getattr(cls, "setup_method", None) setup = getattr(cls, "setup_method", None)
teardown = getattr(cls, "teardown_method", None) teardown = getattr(cls, "teardown_method", None)
if setup is None and teardown is None: if setup is None and teardown is None:
return None return None
@pytest.fixture( def unittest_setup_method_fixture(
scope="function", request: FixtureRequest,
autouse=True, ) -> Generator[None, None, None]:
# Use a unique name to speed up lookup. self = request.instance
name=f"_unittest_setup_method_fixture_{cls.__qualname__}",
)
def fixture(self, request: FixtureRequest) -> Generator[None, None, None]:
if _is_skipped(self): if _is_skipped(self):
reason = self.__unittest_skip_why__ reason = self.__unittest_skip_why__
raise pytest.skip.Exception(reason, _use_item_location=True) raise pytest.skip.Exception(reason, _use_item_location=True)
@ -153,7 +154,14 @@ class UnitTestCase(Class):
if teardown is not None: if teardown is not None:
teardown(self, request.function) teardown(self, request.function)
cls.__pytest_method_setup = fixture # type: ignore[attr-defined] self.session._fixturemanager._register_fixture(
# Use a unique name to speed up lookup.
name=f"_unittest_setup_method_fixture_{cls.__qualname__}",
func=unittest_setup_method_fixture,
nodeid=self.nodeid,
scope="function",
autouse=True,
)
class TestCaseFunction(Function): class TestCaseFunction(Function):