diff --git a/changelog/12017.contrib.rst b/changelog/12017.contrib.rst
new file mode 100644
index 00000000000..ec1861893b3
--- /dev/null
+++ b/changelog/12017.contrib.rst
@@ -0,0 +1,7 @@
+Mixed internal improvements:
+
+* Migrate formatting to f-strings in some tests.
+* Use type-safe constructs in JUnitXML tests.
+* Moved`` MockTiming`` into ``_pytest.timing``.
+
+-- by :user:`RonnyPfannschmidt`
diff --git a/src/_pytest/setuponly.py b/src/_pytest/setuponly.py
index 1e887a896f5..7e6b46bcdb4 100644
--- a/src/_pytest/setuponly.py
+++ b/src/_pytest/setuponly.py
@@ -73,13 +73,9 @@ def _show_fixture_action(
# Use smaller indentation the higher the scope: Session = 0, Package = 1, etc.
scope_indent = list(reversed(Scope)).index(fixturedef._scope)
tw.write(" " * 2 * scope_indent)
- tw.write(
- "{step} {scope} {fixture}".format( # noqa: UP032 (Readability)
- step=msg.ljust(8), # align the output to TEARDOWN
- scope=fixturedef.scope[0].upper(),
- fixture=fixturedef.argname,
- )
- )
+
+ scopename = fixturedef.scope[0].upper()
+ tw.write(f"{msg:<8} {scopename} {fixturedef.argname}")
if msg == "SETUP":
deps = sorted(arg for arg in fixturedef.argnames if arg != "request")
diff --git a/src/_pytest/timing.py b/src/_pytest/timing.py
index b23c7f69e2d..4422037a9d9 100644
--- a/src/_pytest/timing.py
+++ b/src/_pytest/timing.py
@@ -8,9 +8,45 @@
from __future__ import annotations
+import dataclasses
+from datetime import datetime
from time import perf_counter
from time import sleep
from time import time
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+ from pytest import MonkeyPatch
+
+
+@dataclasses.dataclass
+class MockTiming:
+ """Mocks _pytest.timing with a known object that can be used to control timing in tests
+ deterministically.
+
+ pytest itself should always use functions from `_pytest.timing` instead of `time` directly.
+
+ This then allows us more control over time during testing, if testing code also
+ uses `_pytest.timing` functions.
+
+ Time is static, and only advances through `sleep` calls, thus tests might sleep over large
+ numbers and obtain accurate time() calls at the end, making tests reliable and instant."""
+
+ _current_time: float = datetime(2020, 5, 22, 14, 20, 50).timestamp()
+
+ def sleep(self, seconds: float) -> None:
+ self._current_time += seconds
+
+ def time(self) -> float:
+ return self._current_time
+
+ def patch(self, monkeypatch: MonkeyPatch) -> None:
+ from _pytest import timing # noqa: PLW0406
+
+ monkeypatch.setattr(timing, "sleep", self.sleep)
+ monkeypatch.setattr(timing, "time", self.time)
+ monkeypatch.setattr(timing, "perf_counter", self.time)
__all__ = ["perf_counter", "sleep", "time"]
diff --git a/testing/conftest.py b/testing/conftest.py
index 45a47cbdbaa..251b430e9cd 100644
--- a/testing/conftest.py
+++ b/testing/conftest.py
@@ -2,7 +2,6 @@
from __future__ import annotations
from collections.abc import Generator
-import dataclasses
import importlib.metadata
import re
import sys
@@ -233,24 +232,8 @@ def mock_timing(monkeypatch: MonkeyPatch):
Time is static, and only advances through `sleep` calls, thus tests might sleep over large
numbers and obtain accurate time() calls at the end, making tests reliable and instant.
"""
-
- @dataclasses.dataclass
- class MockTiming:
- _current_time: float = 1590150050.0
-
- def sleep(self, seconds: float) -> None:
- self._current_time += seconds
-
- def time(self) -> float:
- return self._current_time
-
- def patch(self) -> None:
- from _pytest import timing
-
- monkeypatch.setattr(timing, "sleep", self.sleep)
- monkeypatch.setattr(timing, "time", self.time)
- monkeypatch.setattr(timing, "perf_counter", self.time)
+ from _pytest.timing import MockTiming
result = MockTiming()
- result.patch()
+ result.patch(monkeypatch)
return result
diff --git a/testing/python/fixtures.py b/testing/python/fixtures.py
index c8d1eb23838..32453739e8c 100644
--- a/testing/python/fixtures.py
+++ b/testing/python/fixtures.py
@@ -2315,14 +2315,14 @@ def test_ordering_dependencies_torndown_first(
) -> None:
"""#226"""
pytester.makepyfile(
- """
+ f"""
import pytest
values = []
- @pytest.fixture(%(param1)s)
+ @pytest.fixture({param1})
def arg1(request):
request.addfinalizer(lambda: values.append("fin1"))
values.append("new1")
- @pytest.fixture(%(param2)s)
+ @pytest.fixture({param2})
def arg2(request, arg1):
request.addfinalizer(lambda: values.append("fin2"))
values.append("new2")
@@ -2331,8 +2331,7 @@ def test_arg(arg2):
pass
def test_check():
assert values == ["new1", "new2", "fin2", "fin1"]
- """ # noqa: UP031 (python syntax issues)
- % locals()
+ """
)
reprec = pytester.inline_run("-s")
reprec.assertoutcome(passed=2)
@@ -3212,21 +3211,21 @@ def test_finalizer_order_on_parametrization(
) -> None:
"""#246"""
pytester.makepyfile(
- """
+ f"""
import pytest
values = []
- @pytest.fixture(scope=%(scope)r, params=["1"])
+ @pytest.fixture(scope={scope!r}, params=["1"])
def fix1(request):
return request.param
- @pytest.fixture(scope=%(scope)r)
+ @pytest.fixture(scope={scope!r})
def fix2(request, base):
def cleanup_fix2():
assert not values, "base should not have been finalized"
request.addfinalizer(cleanup_fix2)
- @pytest.fixture(scope=%(scope)r)
+ @pytest.fixture(scope={scope!r})
def base(request, fix1):
def cleanup_base():
values.append("fin_base")
@@ -3239,8 +3238,7 @@ def test_baz(base, fix2):
pass
def test_other():
pass
- """ # noqa: UP031 (python syntax issues)
- % {"scope": scope}
+ """
)
reprec = pytester.inline_run("-lvs")
reprec.assertoutcome(passed=3)
@@ -3426,42 +3424,40 @@ class TestRequestScopeAccess:
def test_setup(self, pytester: Pytester, scope, ok, error) -> None:
pytester.makepyfile(
- """
+ f"""
import pytest
- @pytest.fixture(scope=%r, autouse=True)
+ @pytest.fixture(scope={scope!r}, autouse=True)
def myscoped(request):
- for x in %r:
+ for x in {ok.split()}:
assert hasattr(request, x)
- for x in %r:
+ for x in {error.split()}:
pytest.raises(AttributeError, lambda:
getattr(request, x))
assert request.session
assert request.config
def test_func():
pass
- """ # noqa: UP031 (python syntax issues)
- % (scope, ok.split(), error.split())
+ """
)
reprec = pytester.inline_run("-l")
reprec.assertoutcome(passed=1)
def test_funcarg(self, pytester: Pytester, scope, ok, error) -> None:
pytester.makepyfile(
- """
+ f"""
import pytest
- @pytest.fixture(scope=%r)
+ @pytest.fixture(scope={scope!r})
def arg(request):
- for x in %r:
+ for x in {ok.split()!r}:
assert hasattr(request, x)
- for x in %r:
+ for x in {error.split()!r}:
pytest.raises(AttributeError, lambda:
getattr(request, x))
assert request.session
assert request.config
def test_func(arg):
pass
- """ # noqa: UP031 (python syntax issues)
- % (scope, ok.split(), error.split())
+ """
)
reprec = pytester.inline_run()
reprec.assertoutcome(passed=1)
diff --git a/testing/test_junitxml.py b/testing/test_junitxml.py
index 5de0e6a5d7a..4145f34ab14 100644
--- a/testing/test_junitxml.py
+++ b/testing/test_junitxml.py
@@ -1,4 +1,3 @@
-# mypy: allow-untyped-defs
from __future__ import annotations
from datetime import datetime
@@ -6,6 +5,7 @@
import os
from pathlib import Path
import platform
+from typing import Any
from typing import cast
from typing import TYPE_CHECKING
from xml.dom import minidom
@@ -21,6 +21,7 @@
from _pytest.reports import BaseReport
from _pytest.reports import TestReport
from _pytest.stash import Stash
+import _pytest.timing
import pytest
@@ -39,7 +40,7 @@ def __init__(self, pytester: Pytester, schema: xmlschema.XMLSchema) -> None:
def __call__(
self, *args: str | os.PathLike[str], family: str | None = "xunit1"
- ) -> tuple[RunResult, DomNode]:
+ ) -> tuple[RunResult, DomDocument]:
if family:
args = ("-o", "junit_family=" + family, *args)
xml_path = self.pytester.path.joinpath("junit.xml")
@@ -48,7 +49,7 @@ def __call__(
with xml_path.open(encoding="utf-8") as f:
self.schema.validate(f)
xmldoc = minidom.parse(str(xml_path))
- return result, DomNode(xmldoc)
+ return result, DomDocument(xmldoc)
@pytest.fixture
@@ -62,78 +63,129 @@ def run_and_parse(pytester: Pytester, schema: xmlschema.XMLSchema) -> RunAndPars
return RunAndParse(pytester, schema)
-def assert_attr(node, **kwargs):
+def assert_attr(node: minidom.Element, **kwargs: object) -> None:
__tracebackhide__ = True
- def nodeval(node, name):
+ def nodeval(node: minidom.Element, name: str) -> str | None:
anode = node.getAttributeNode(name)
- if anode is not None:
- return anode.value
+ return anode.value if anode is not None else None
expected = {name: str(value) for name, value in kwargs.items()}
on_node = {name: nodeval(node, name) for name in expected}
assert on_node == expected
-class DomNode:
- def __init__(self, dom):
- self.__node = dom
+class DomDocument:
+ def __init__(self, dom: minidom.Document):
+ self._node = dom
- def __repr__(self):
- return self.__node.toxml()
+ _node: minidom.Document | minidom.Element
- def find_first_by_tag(self, tag):
+ def find_first_by_tag(self, tag: str) -> DomNode | None:
return self.find_nth_by_tag(tag, 0)
- def _by_tag(self, tag):
- return self.__node.getElementsByTagName(tag)
+ def get_first_by_tag(self, tag: str) -> DomNode:
+ maybe = self.find_first_by_tag(tag)
+ if maybe is None:
+ raise LookupError(tag)
+ else:
+ return maybe
+
+ def find_nth_by_tag(self, tag: str, n: int) -> DomNode | None:
+ items = self._node.getElementsByTagName(tag)
+ try:
+ nth = items[n]
+ except IndexError:
+ return None
+ else:
+ return DomNode(nth)
+
+ def find_by_tag(self, tag: str) -> list[DomNode]:
+ return [DomNode(x) for x in self._node.getElementsByTagName(tag)]
@property
- def children(self):
- return [type(self)(x) for x in self.__node.childNodes]
+ def children(self) -> list[DomNode]:
+ return [DomNode(x) for x in self._node.childNodes]
@property
- def get_unique_child(self):
+ def get_unique_child(self) -> DomNode:
children = self.children
assert len(children) == 1
return children[0]
- def find_nth_by_tag(self, tag, n):
- items = self._by_tag(tag)
- try:
- nth = items[n]
- except IndexError:
- pass
- else:
- return type(self)(nth)
+ def toxml(self) -> str:
+ return self._node.toxml()
+
+
+class DomNode(DomDocument):
+ _node: minidom.Element
+
+ def __init__(self, dom: minidom.Element):
+ self._node = dom
- def find_by_tag(self, tag):
- t = type(self)
- return [t(x) for x in self.__node.getElementsByTagName(tag)]
+ def __repr__(self) -> str:
+ return self.toxml()
- def __getitem__(self, key):
- node = self.__node.getAttributeNode(key)
+ def __getitem__(self, key: str) -> str:
+ node = self._node.getAttributeNode(key)
if node is not None:
- return node.value
+ return cast(str, node.value)
+ else:
+ raise KeyError(key)
- def assert_attr(self, **kwargs):
+ def assert_attr(self, **kwargs: object) -> None:
__tracebackhide__ = True
- return assert_attr(self.__node, **kwargs)
-
- def toxml(self):
- return self.__node.toxml()
+ return assert_attr(self._node, **kwargs)
@property
- def text(self):
- return self.__node.childNodes[0].wholeText
+ def text(self) -> str:
+ return cast(str, self._node.childNodes[0].wholeText)
@property
- def tag(self):
- return self.__node.tagName
+ def tag(self) -> str:
+ return self._node.tagName
- @property
- def next_sibling(self):
- return type(self)(self.__node.nextSibling)
+
+class TestJunitHelpers:
+ """minimal test to increase coverage for methods that are used in debugging"""
+
+ @pytest.fixture
+ def document(self) -> DomDocument:
+ doc = minidom.parseString("""
+
+