Rename Instant.duration() to Instant.elapsed()

While at it, noticed that `Duration.seconds` reads much better than `Duration.elapsed_s`.

Author: nicoddemus

src/_pytest/junitxml.py

@@ -642,7 +642,7 @@ def pytest_sessionfinish(self) -> None:
         os.makedirs(dirname, exist_ok=True)
 
         with open(self.logfile, "w", encoding="utf-8") as logfile:
-            duration = self.suite_start.duration()
+            duration = self.suite_start.elapsed()
 
             numtests = (
                 self.stats["passed"]
@@ -660,7 +660,7 @@ def pytest_sessionfinish(self) -> None:
                 failures=str(self.stats["failure"]),
                 skipped=str(self.stats["skipped"]),
                 tests=str(numtests),
-                time=f"{duration.elapsed_s:.3f}",
+                time=f"{duration.seconds:.3f}",
                 timestamp=self.suite_start.as_utc().astimezone().isoformat(),
                 hostname=platform.node(),
             )

src/_pytest/pytester.py

@@ -1180,7 +1180,7 @@ class reprec:  # type: ignore
 
         assert reprec.ret is not None
         res = RunResult(
-            reprec.ret, out.splitlines(), err.splitlines(), instant.duration().elapsed_s
+            reprec.ret, out.splitlines(), err.splitlines(), instant.elapsed().seconds
         )
         res.reprec = reprec  # type: ignore
         return res
@@ -1445,7 +1445,7 @@ def handle_timeout() -> None:
 
         with contextlib.suppress(ValueError):
             ret = ExitCode(ret)
-        return RunResult(ret, out, err, instant.duration().elapsed_s)
+        return RunResult(ret, out, err, instant.elapsed().seconds)
 
     def _dump_lines(self, lines, fp):
         try:

src/_pytest/runner.py

@@ -347,11 +347,11 @@ def from_call(
             if reraise is not None and isinstance(excinfo.value, reraise):
                 raise
             result = None
-        duration = instant.duration()
+        duration = instant.elapsed()
         return cls(
             start=duration.start.time,
             stop=duration.stop.time,
-            duration=duration.elapsed_s,
+            duration=duration.seconds,
             when=when,
             result=result,
             excinfo=excinfo,

src/_pytest/terminal.py

@@ -789,7 +789,7 @@ def report_collect(self, final: bool = False) -> None:
         if not final:
             # Only write the "collecting" report every `REPORT_COLLECTING_RESOLUTION`.
             if (
-                self._collect_report_last_write.duration().elapsed_s
+                self._collect_report_last_write.elapsed().seconds
                 < REPORT_COLLECTING_RESOLUTION
             ):
                 return
@@ -1200,7 +1200,7 @@ def summary_stats(self) -> None:
         if self.verbosity < -1:
             return
 
-        session_duration = self._session_start.duration()
+        session_duration = self._session_start.elapsed()
         (parts, main_color) = self.build_summary_stats_line()
         line_parts = []
 
@@ -1215,7 +1215,7 @@ def summary_stats(self) -> None:
         msg = ", ".join(line_parts)
 
         main_markup = {main_color: True}
-        duration = f" in {format_session_duration(session_duration.elapsed_s)}"
+        duration = f" in {format_session_duration(session_duration.seconds)}"
         duration_with_markup = self._tw.markup(duration, **main_markup)
         if display_sep:
             fullwidth += len(duration_with_markup) - len(duration)

src/_pytest/timing.py

@@ -31,16 +31,16 @@ class Instant:
     """
 
     # Creation time of this instant, using time.time(), to measure actual time.
-    # Use a `lambda` to initialize the default to correctly get the mocked time via `MockTiming`.
+    # Note: using a `lambda` to correctly get the mocked time via `MockTiming`.
     time: float = dataclasses.field(default_factory=lambda: time(), init=False)
 
     # Performance counter tick of the instant, used to measure precise elapsed time.
-    # Use a `lambda` to initialize the default to correctly get the mocked time via `MockTiming`.
+    # Note: using a `lambda` to correctly get the mocked time via `MockTiming`.
     perf_count: float = dataclasses.field(
         default_factory=lambda: perf_counter(), init=False
     )
 
-    def duration(self) -> Duration:
+    def elapsed(self) -> Duration:
         """Measure the duration since `Instant` was created."""
         return Duration(start=self, stop=Instant())
 
@@ -57,8 +57,8 @@ class Duration:
     stop: Instant
 
     @property
-    def elapsed_s(self) -> float:
-        """Elapsed time of the duration, in seconds, measured using a performance counter for precise timing."""
+    def seconds(self) -> float:
+        """Elapsed time of the duration in seconds, measured using a performance counter for precise timing."""
         return self.stop.perf_count - self.start.perf_count
 
 

testing/test_pytester.py

@@ -453,10 +453,10 @@ def test_pytester_run_with_timeout(pytester: Pytester) -> None:
 
     instant = _pytest.timing.Instant()
     result = pytester.runpytest_subprocess(testfile, timeout=timeout)
-    duration = instant.duration()
+    duration = instant.elapsed()
 
     assert result.ret == ExitCode.OK
-    assert duration.elapsed_s < timeout
+    assert duration.seconds < timeout
 
 
 def test_pytester_run_timeout_expires(pytester: Pytester) -> None: