pytest-collect-profile 0.1.0__tar.gz

pytest_collect_profile-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.venv/
+build/
+dist/
+*.egg-info/

pytest_collect_profile-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,99 @@
+# Contributing
+
+Thanks for your interest in `pytest-collect-profile`. The project has one
+purpose: find what makes pytest collection slow. Its only user-facing interface
+is `pytest --collect-profile`.
+
+## Scope
+
+Before proposing a change, make sure it:
+
+- helps users find slow pytest collection (not slow tests or general CI costs);
+- works through the single `--collect-profile` interface;
+- does not change pytest's test selection, execution, or exit status;
+- uses public pytest hooks and the standard library where possible.
+
+Changes that add options, configuration, or new subsystems before the first
+release are out of scope.
+
+## Workflow
+
+1. Start from the default branch (`main`).
+2. Create a short-lived topic branch with one of these prefixes:
+
+   ```text
+   feat/<short-slug>    new behavior
+   fix/<short-slug>     defect fix
+   docs/<short-slug>    documentation only
+   test/<short-slug>    tests only
+   chore/<short-slug>   tooling, packaging, maintenance
+   ```
+
+   Keep the slug short and use lowercase kebab-case, for example
+   `fix/slow-module-import`.
+
+3. Keep the branch focused on one logical change.
+4. Bring in changes from `main` by rebasing or merging when needed.
+
+## Local checks
+
+Create and activate a virtual environment, then install the project and its
+development tools:
+
+```bash
+python -m pip install --editable . build "ruff==0.16.6"
+```
+
+Run the Python lint, formatting, and test checks before opening a pull request:
+
+```bash
+python -m ruff check .
+python -m ruff format --check .
+python -m pytest -q
+```
+
+## Commits
+
+Use Conventional Commit subjects:
+
+```text
+feat: rank custom collectors without special casing
+fix: keep report silent when the flag is absent
+docs: document interpretation of the summary line
+test: cover fewer-than-10 collector output
+chore: set up minimal packaging
+```
+
+- Write the subject in the imperative mood, in lowercase, without a trailing
+  period, and keep it to 72 characters or fewer.
+- The body is optional. Use it to explain *why*, not *what*, and wrap it at
+  about 72 characters.
+- Write commits and pull requests in English.
+
+## Releases
+
+Versions follow [SemVer](https://semver.org/) (`MAJOR.MINOR.PATCH`) and each
+release is tagged `v<major>.<minor>.<patch>`, e.g. `v0.1.0`.
+
+## Pull requests
+
+Use a Conventional Commit-style pull request title that describes the primary
+change, for example `docs: add contribution workflow`.
+
+Briefly explain the purpose of the change, summarize what changed, and record
+which checks were run.
+
+Pull requests are squash-merged into `main`. Use the pull request title as the
+squash commit subject. Delete the topic branch after merging.
+
+Before opening a pull request:
+
+- Run the project's test suite (and any documented lint/build checks once
+  tooling is established).
+- Add tests for new behavior. For a defect fix, add the smallest regression
+  check.
+- Update the documentation the change affects.
+- Verify the diff contains no secrets, machine-specific paths, or unrelated
+  work.
+
+Keep pull requests small and self-contained.

pytest_collect_profile-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jan Mrowiec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_collect_profile-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: pytest-collect-profile
+Version: 0.1.0
+Summary: Find what makes pytest collection slow
+Project-URL: Repository, https://github.com/janmrow/pytest-collect-profile
+Project-URL: Issues, https://github.com/janmrow/pytest-collect-profile/issues
+Author: Jan Mrowiec
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: pytest>=8.0
+Description-Content-Type: text/markdown
+
+# pytest-collect-profile
+
+Find what makes pytest collection slow.
+
+`pytest-collect-profile` is a pytest plugin that reports the slowest collector
+operations and the total collection time before tests begin to run. It measures
+pytest's collection model directly, including custom collectors, rather than
+guessing from file layout.
+
+## Installation
+
+Install the plugin in the environment where pytest runs:
+
+```bash
+python -m pip install pytest-collect-profile
+```
+
+To install from a source checkout instead:
+
+```bash
+python -m pip install .
+```
+
+## Quick start
+
+Run the normal test suite with collection profiling enabled:
+
+```bash
+pytest --collect-profile
+```
+
+To inspect collection without executing tests, combine the plugin flag with
+pytest's existing `--collect-only` option:
+
+```bash
+pytest --collect-profile --collect-only
+```
+
+`--collect-profile` does not imply `--collect-only`; without the latter, pytest
+continues to execute the selected tests normally.
+
+## Example
+
+```text
+====================== collect profile ======================
+time      collector   node
+1.421s    Module      tests/integration/test_api.py
+0.612s    Class       tests/test_users.py::TestUsers
+0.184s    Directory   tests/integration
+
+Total collection: 2.340s | 842 items
+```
+
+The banner padding may change with terminal width. The report itself always
+uses seconds with three decimal places and shows at most 10 collector operations,
+ordered by measured duration. An empty root-session node ID appears as
+`<session>`.
+
+Each row measures one collector operation. Collector calls may be nested, so row
+times can overlap. `Total collection` is measured separately and includes work
+outside collector calls, such as item modification hooks. Do not add the rows or
+expect their sum to equal the total.
+
+The report helps locate where collection time is spent. It does not explain why
+a collector is slow or guarantee that optimizing one displayed row will reduce
+the total by the same amount.
+
+## Behavior
+
+- The plugin is silent unless `--collect-profile` is present.
+- The report appears after collection and before test execution.
+- Selection, execution, collection errors, test failures, and exit statuses
+  remain pytest's responsibility.
+- Timings and records exist only for the current pytest process; the plugin
+  creates no history, cache, network request, or external service.
+
+## Compatibility
+
+`pytest-collect-profile` requires Python 3.10 or newer and pytest 8.0 or newer.
+Version `0.1.0` targets Linux, macOS, and Windows.
+
+The project's GitHub Actions matrix has passed for Python 3.10 through 3.14,
+representative pytest 8.x and 9.x releases, and Linux, macOS, and Windows.
+
+## Limitations
+
+Version `0.1.0` profiles collection only. It does not profile test execution,
+fixtures, functions, or call stacks; explain the cause of slowness; produce JSON,
+HTML, or flamegraphs; store history; compare runs; enforce thresholds; or offer
+configurable ranking and filters. It provides no special xdist guarantees.
+
+See the
+[contribution guide](https://github.com/janmrow/pytest-collect-profile/blob/main/CONTRIBUTING.md)
+for contribution guidance. This project is available under the terms of the
+[MIT License](https://github.com/janmrow/pytest-collect-profile/blob/main/LICENSE).

pytest_collect_profile-0.1.0/README.md

@@ -0,0 +1,95 @@
+# pytest-collect-profile
+
+Find what makes pytest collection slow.
+
+`pytest-collect-profile` is a pytest plugin that reports the slowest collector
+operations and the total collection time before tests begin to run. It measures
+pytest's collection model directly, including custom collectors, rather than
+guessing from file layout.
+
+## Installation
+
+Install the plugin in the environment where pytest runs:
+
+```bash
+python -m pip install pytest-collect-profile
+```
+
+To install from a source checkout instead:
+
+```bash
+python -m pip install .
+```
+
+## Quick start
+
+Run the normal test suite with collection profiling enabled:
+
+```bash
+pytest --collect-profile
+```
+
+To inspect collection without executing tests, combine the plugin flag with
+pytest's existing `--collect-only` option:
+
+```bash
+pytest --collect-profile --collect-only
+```
+
+`--collect-profile` does not imply `--collect-only`; without the latter, pytest
+continues to execute the selected tests normally.
+
+## Example
+
+```text
+====================== collect profile ======================
+time      collector   node
+1.421s    Module      tests/integration/test_api.py
+0.612s    Class       tests/test_users.py::TestUsers
+0.184s    Directory   tests/integration
+
+Total collection: 2.340s | 842 items
+```
+
+The banner padding may change with terminal width. The report itself always
+uses seconds with three decimal places and shows at most 10 collector operations,
+ordered by measured duration. An empty root-session node ID appears as
+`<session>`.
+
+Each row measures one collector operation. Collector calls may be nested, so row
+times can overlap. `Total collection` is measured separately and includes work
+outside collector calls, such as item modification hooks. Do not add the rows or
+expect their sum to equal the total.
+
+The report helps locate where collection time is spent. It does not explain why
+a collector is slow or guarantee that optimizing one displayed row will reduce
+the total by the same amount.
+
+## Behavior
+
+- The plugin is silent unless `--collect-profile` is present.
+- The report appears after collection and before test execution.
+- Selection, execution, collection errors, test failures, and exit statuses
+  remain pytest's responsibility.
+- Timings and records exist only for the current pytest process; the plugin
+  creates no history, cache, network request, or external service.
+
+## Compatibility
+
+`pytest-collect-profile` requires Python 3.10 or newer and pytest 8.0 or newer.
+Version `0.1.0` targets Linux, macOS, and Windows.
+
+The project's GitHub Actions matrix has passed for Python 3.10 through 3.14,
+representative pytest 8.x and 9.x releases, and Linux, macOS, and Windows.
+
+## Limitations
+
+Version `0.1.0` profiles collection only. It does not profile test execution,
+fixtures, functions, or call stacks; explain the cause of slowness; produce JSON,
+HTML, or flamegraphs; store history; compare runs; enforce thresholds; or offer
+configurable ranking and filters. It provides no special xdist guarantees.
+
+See the
+[contribution guide](https://github.com/janmrow/pytest-collect-profile/blob/main/CONTRIBUTING.md)
+for contribution guidance. This project is available under the terms of the
+[MIT License](https://github.com/janmrow/pytest-collect-profile/blob/main/LICENSE).

pytest_collect_profile-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pytest-collect-profile"
+version = "0.1.0"
+description = "Find what makes pytest collection slow"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Jan Mrowiec" }]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Framework :: Pytest",
+  "Programming Language :: Python :: 3",
+]
+dependencies = [
+  "pytest>=8.0",
+]
+
+[project.urls]
+Repository = "https://github.com/janmrow/pytest-collect-profile"
+Issues = "https://github.com/janmrow/pytest-collect-profile/issues"
+
+[project.entry-points.pytest11]
+collect-profile = "pytest_collect_profile.plugin"
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+  "CONTRIBUTING.md",
+  "README.md",
+  "src",
+  "tests",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pytest_collect_profile"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["B", "E4", "E7", "E9", "F", "I", "UP"]

pytest_collect_profile-0.1.0/src/pytest_collect_profile/__init__.py

@@ -0,0 +1 @@
+"""Profile pytest collection at pytest's collector boundaries."""

pytest_collect_profile-0.1.0/src/pytest_collect_profile/plugin.py

@@ -0,0 +1,116 @@
+"""Pytest hooks for collection profiling."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from time import perf_counter_ns
+
+import pytest
+
+_OPTION = "--collect-profile"
+_RUNTIME_PLUGIN_NAME = "pytest-collect-profile-runtime"
+_ROW_LIMIT = 10
+
+
+@dataclass(frozen=True)
+class _CollectorTiming:
+    duration_ns: int
+    collector_type: str
+    nodeid: str
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("collect profile")
+    group.addoption(
+        _OPTION,
+        action="store_true",
+        default=False,
+        help="show the slowest collectors after collection",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    if config.getoption(_OPTION):
+        config.pluginmanager.register(
+            _CollectProfilePlugin(config), name=_RUNTIME_PLUGIN_NAME
+        )
+
+
+class _CollectProfilePlugin:
+    def __init__(
+        self,
+        config: pytest.Config,
+        clock: Callable[[], int] = perf_counter_ns,
+    ) -> None:
+        self._config = config
+        self._clock = clock
+        self._collector_timings: list[_CollectorTiming] = []
+
+    @pytest.hookimpl(wrapper=True, tryfirst=True)
+    def pytest_make_collect_report(self, collector: pytest.Collector):
+        started_at = self._clock()
+        try:
+            result = yield
+        finally:
+            self._collector_timings.append(
+                _CollectorTiming(
+                    duration_ns=self._clock() - started_at,
+                    collector_type=type(collector).__name__,
+                    nodeid=collector.nodeid,
+                )
+            )
+        return result
+
+    @pytest.hookimpl(wrapper=True, tryfirst=True)
+    def pytest_collection(self, session: pytest.Session):
+        started_at = self._clock()
+        result = yield
+        total_duration_ns = self._clock() - started_at
+        self._write_report(total_duration_ns, len(session.items))
+        return result
+
+    def _write_report(self, total_duration_ns: int, item_count: int) -> None:
+        terminal_reporter = self._config.pluginmanager.get_plugin("terminalreporter")
+        if terminal_reporter is None:
+            return
+
+        terminal_reporter.section("collect profile")
+        for line in _report_lines(
+            self._collector_timings, total_duration_ns, item_count
+        ):
+            terminal_reporter.write_line(line)
+
+
+def _rank_timings(timings: Iterable[_CollectorTiming]) -> list[_CollectorTiming]:
+    return sorted(
+        timings,
+        key=lambda timing: (
+            -timing.duration_ns,
+            timing.nodeid,
+            timing.collector_type,
+        ),
+    )[:_ROW_LIMIT]
+
+
+def _report_lines(
+    timings: Iterable[_CollectorTiming], total_duration_ns: int, item_count: int
+) -> list[str]:
+    lines = [f"{'time':<6}    {'collector':<11} node"]
+
+    for timing in _rank_timings(timings):
+        duration = _format_duration(timing.duration_ns)
+        nodeid = timing.nodeid or "<session>"
+        lines.append(f"{duration:<6}    {timing.collector_type:<11} {nodeid}")
+
+    lines.extend(
+        [
+            "",
+            f"Total collection: {_format_duration(total_duration_ns)} | {item_count} items",
+        ]
+    )
+    return lines
+
+
+def _format_duration(duration_ns: int) -> str:
+    return f"{duration_ns / 1_000_000_000:.3f}s"

pytest_collect_profile-0.1.0/tests/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ["pytester"]

pytest_collect_profile-0.1.0/tests/smoke_installed.py

@@ -0,0 +1,273 @@
+"""Exercise the public workflow from an installed wheel in a fresh environment."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import shlex
+import subprocess
+import sys
+import tempfile
+import venv
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("wheel", type=Path)
+    wheel = parser.parse_args().wheel.resolve(strict=True)
+
+    with tempfile.TemporaryDirectory(prefix="pytest-collect-profile-smoke-") as root:
+        root_path = Path(root)
+        environment = root_path / "venv"
+        suite = root_path / "suite"
+        suite.mkdir()
+
+        venv.EnvBuilder(with_pip=True).create(environment)
+        python = _environment_python(environment)
+        pytest_command = _environment_pytest(environment)
+        clean_environment = _clean_subprocess_environment()
+
+        _run(
+            python,
+            "-m",
+            "pip",
+            "install",
+            str(wheel),
+            environment=clean_environment,
+            timeout=120,
+        )
+        _write_suite(suite)
+        execution_marker = suite / "test-executed"
+
+        help_result = _run(
+            python,
+            "-m",
+            "pytest",
+            "--help",
+            cwd=suite,
+            environment=clean_environment,
+        )
+        _require(
+            help_result.stdout.count("--collect-profile") == 1,
+            "installed pytest did not expose exactly one --collect-profile option",
+            help_result,
+        )
+
+        collect_only_result = _run(
+            pytest_command,
+            "--collect-profile",
+            "--collect-only",
+            cwd=suite,
+            environment=clean_environment,
+        )
+        _check_collect_only_run(collect_only_result)
+        _require(
+            not execution_marker.exists(),
+            "the README collect-only workflow executed a test",
+            collect_only_result,
+        )
+
+        profiled_result = _run(
+            python,
+            "-m",
+            "pytest",
+            "-q",
+            "-s",
+            "--collect-profile",
+            cwd=suite,
+            environment=clean_environment,
+        )
+        _check_profiled_run(profiled_result)
+        _require(
+            execution_marker.exists(),
+            "--collect-profile prevented normal test execution",
+            profiled_result,
+        )
+        execution_marker.unlink()
+
+        unprofiled_result = _run(
+            python,
+            "-m",
+            "pytest",
+            "-q",
+            "-s",
+            cwd=suite,
+            environment=clean_environment,
+        )
+        _check_unprofiled_run(unprofiled_result)
+        _require(
+            execution_marker.exists(),
+            "the unprofiled test did not execute",
+            unprofiled_result,
+        )
+
+    print("installed wheel smoke test passed")
+
+
+def _environment_python(environment: Path) -> Path:
+    if os.name == "nt":
+        return environment / "Scripts" / "python.exe"
+    return environment / "bin" / "python"
+
+
+def _environment_pytest(environment: Path) -> Path:
+    if os.name == "nt":
+        return environment / "Scripts" / "pytest.exe"
+    return environment / "bin" / "pytest"
+
+
+def _clean_subprocess_environment() -> dict[str, str]:
+    environment = os.environ.copy()
+    for name in (
+        "PYTHONPATH",
+        "PYTEST_ADDOPTS",
+        "PYTEST_DISABLE_PLUGIN_AUTOLOAD",
+        "PYTEST_PLUGINS",
+    ):
+        environment.pop(name, None)
+    return environment
+
+
+def _write_suite(suite: Path) -> None:
+    (suite / "conftest.py").write_text(
+        """
+import time
+
+import pytest
+
+
+class SlowFile(pytest.File):
+    def collect(self):
+        time.sleep(0.03)
+        return []
+
+
+def pytest_collect_file(file_path, parent):
+    if file_path.name == "slow.case":
+        return SlowFile.from_parent(parent, path=file_path)
+""".lstrip(),
+        encoding="utf-8",
+    )
+    (suite / "slow.case").write_text("content\n", encoding="utf-8")
+    (suite / "test_sample.py").write_text(
+        """
+from pathlib import Path
+
+
+def test_runs():
+    Path("test-executed").write_text("executed", encoding="utf-8")
+    print("TEST EXECUTED")
+""".lstrip(),
+        encoding="utf-8",
+    )
+
+
+def _run(
+    *command: str | Path,
+    cwd: Path | None = None,
+    environment: dict[str, str],
+    timeout: int = 30,
+) -> subprocess.CompletedProcess[str]:
+    string_command = [str(part) for part in command]
+    result = subprocess.run(
+        string_command,
+        cwd=cwd,
+        env=environment,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+    _require(
+        result.returncode == 0,
+        f"command failed: {shlex.join(string_command)}",
+        result,
+    )
+    return result
+
+
+def _check_profiled_run(result: subprocess.CompletedProcess[str]) -> None:
+    output = result.stdout
+    _require(
+        re.search(
+            r"(?m)^time\s+collector\s+node\n"
+            r"\d+\.\d{3}s\s+SlowFile\s+slow\.case$",
+            output,
+        )
+        is not None,
+        "the deliberately slow collector was not the first reported row",
+        result,
+    )
+    _require(
+        re.search(r"Total collection: \d+\.\d{3}s \| 1 items", output) is not None,
+        "the installed plugin did not print the collection summary",
+        result,
+    )
+    _require(
+        "TEST EXECUTED" in output,
+        "--collect-profile prevented normal test execution",
+        result,
+    )
+    _require(
+        output.index("collect profile") < output.index("TEST EXECUTED"),
+        "the collection report did not appear before test execution",
+        result,
+    )
+    _require("1 passed" in output, "the profiled test did not pass", result)
+
+
+def _check_collect_only_run(result: subprocess.CompletedProcess[str]) -> None:
+    output = result.stdout
+    _require(
+        re.search(
+            r"(?m)^time\s+collector\s+node\n"
+            r"\d+\.\d{3}s\s+SlowFile\s+slow\.case$",
+            output,
+        )
+        is not None,
+        "the README workflow did not rank the deliberately slow collector first",
+        result,
+    )
+    _require(
+        re.search(r"Total collection: \d+\.\d{3}s \| 1 items", output) is not None,
+        "the README workflow did not print the collection summary",
+        result,
+    )
+    _require(
+        "1 test collected" in output,
+        "the README workflow did not preserve pytest's collect-only outcome",
+        result,
+    )
+
+
+def _check_unprofiled_run(result: subprocess.CompletedProcess[str]) -> None:
+    output = result.stdout
+    _require(
+        "collect profile" not in output,
+        "the installed plugin printed a report without its option",
+        result,
+    )
+    _require("TEST EXECUTED" in output, "the unprofiled test did not run", result)
+    _require("1 passed" in output, "the unprofiled test did not pass", result)
+
+
+def _require(
+    condition: bool,
+    message: str,
+    result: subprocess.CompletedProcess[str],
+) -> None:
+    if condition:
+        return
+
+    raise RuntimeError(
+        f"{message}\n\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+    )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, RuntimeError, subprocess.SubprocessError) as error:
+        sys.exit(str(error))

pytest_collect_profile-0.1.0/tests/test_plugin.py

@@ -0,0 +1,393 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from pytest_collect_profile import plugin
+from pytest_collect_profile.plugin import (
+    _CollectorTiming,
+    _CollectProfilePlugin,
+    _format_duration,
+    _report_lines,
+)
+
+
+def _timing(duration_ns: int, collector_type: str, nodeid: str) -> _CollectorTiming:
+    return _CollectorTiming(duration_ns, collector_type, nodeid)
+
+
+def test_duration_uses_fixed_seconds_with_three_decimal_places() -> None:
+    assert _format_duration(1_421_400_000) == "1.421s"
+    assert _format_duration(400_000) == "0.000s"
+
+
+def test_report_formats_rows_session_label_and_summary() -> None:
+    lines = _report_lines(
+        [
+            _timing(1_421_000_000, "Module", "tests/test_api.py"),
+            _timing(612_000_000, "Session", ""),
+        ],
+        total_duration_ns=2_340_000_000,
+        item_count=842,
+    )
+
+    assert lines == [
+        "time      collector   node",
+        "1.421s    Module      tests/test_api.py",
+        "0.612s    Session     <session>",
+        "",
+        "Total collection: 2.340s | 842 items",
+    ]
+
+
+def test_report_separates_long_collector_type_from_nodeid() -> None:
+    lines = _report_lines(
+        [_timing(1_000_000_000, "VeryLongCollector", "tests/test_api.py")],
+        total_duration_ns=1_000_000_000,
+        item_count=1,
+    )
+
+    assert lines[1] == "1.000s    VeryLongCollector tests/test_api.py"
+
+
+def test_report_sorts_raw_timings_before_display_rounding() -> None:
+    lines = _report_lines(
+        [
+            _timing(1_000_400_000, "Module", "tests/a.py"),
+            _timing(1_000_499_999, "Module", "tests/z.py"),
+        ],
+        total_duration_ns=2_000_000_000,
+        item_count=2,
+    )
+
+    assert lines[1:3] == [
+        "1.000s    Module      tests/z.py",
+        "1.000s    Module      tests/a.py",
+    ]
+
+
+def test_report_breaks_exact_ties_by_nodeid_then_collector_type() -> None:
+    lines = _report_lines(
+        [
+            _timing(1_000_000_000, "Package", "tests/z.py"),
+            _timing(1_000_000_000, "Module", "tests/a.py"),
+            _timing(1_000_000_000, "Class", "tests/a.py"),
+        ],
+        total_duration_ns=3_000_000_000,
+        item_count=3,
+    )
+
+    assert lines[1:4] == [
+        "1.000s    Class       tests/a.py",
+        "1.000s    Module      tests/a.py",
+        "1.000s    Package     tests/z.py",
+    ]
+
+
+def test_report_limits_rows_to_ten_without_ellipsis() -> None:
+    timings = [
+        _timing(index, "Module", f"tests/test_{index}.py") for index in range(12)
+    ]
+
+    lines = _report_lines(timings, total_duration_ns=100, item_count=12)
+
+    assert len(lines) == 13
+    assert "..." not in "\n".join(lines)
+    assert "tests/test_11.py" in lines[1]
+    assert "tests/test_2.py" in lines[10]
+
+
+def test_report_keeps_every_row_when_fewer_than_ten_exist() -> None:
+    timings = [_timing(index, "Module", f"tests/test_{index}.py") for index in range(3)]
+
+    lines = _report_lines(timings, total_duration_ns=100, item_count=3)
+
+    assert len(lines) == 6
+
+
+def test_nested_measurement_hooks_keep_inclusive_timings(pytester) -> None:
+    class ParentCollector:
+        nodeid = "parent"
+
+    class ChildCollector:
+        nodeid = "parent::child"
+
+    clock_values = iter([0, 10, 30, 50])
+    runtime = _CollectProfilePlugin(
+        config=pytester.parseconfig(),
+        clock=lambda: next(clock_values),
+    )
+
+    parent_hook = runtime.pytest_make_collect_report(ParentCollector())
+    assert next(parent_hook) is None
+    child_hook = runtime.pytest_make_collect_report(ChildCollector())
+    assert next(child_hook) is None
+
+    child_result = object()
+    with pytest.raises(StopIteration) as child_finished:
+        child_hook.send(child_result)
+    assert child_finished.value.value is child_result
+
+    parent_result = object()
+    with pytest.raises(StopIteration) as parent_finished:
+        parent_hook.send(parent_result)
+    assert parent_finished.value.value is parent_result
+
+    assert runtime._collector_timings == [
+        _timing(20, "ChildCollector", "parent::child"),
+        _timing(50, "ParentCollector", "parent"),
+    ]
+
+
+def test_option_is_registered_once(pytester, monkeypatch) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+
+    result = pytester.runpytest_inprocess("--help", plugins=[plugin])
+
+    result.stdout.fnmatch_lines(["*--collect-profile*slowest collectors*"])
+    assert result.stdout.str().count("--collect-profile") == 1
+
+
+def test_disabled_plugin_is_silent_and_does_not_prevent_execution(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makepyfile(
+        """
+        def test_runs():
+            print("TEST EXECUTED")
+        """
+    )
+
+    result = pytester.runpytest_inprocess("-q", "-s", plugins=[plugin])
+
+    result.assert_outcomes(passed=1)
+    result.stdout.fnmatch_lines(["*TEST EXECUTED*"])
+    assert "collect profile" not in result.stdout.str()
+
+
+def test_enabled_plugin_ranks_a_slow_collector_and_reports_before_execution(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makeconftest(
+        """
+        import time
+        import pytest
+
+        class SlowFile(pytest.File):
+            def collect(self):
+                time.sleep(0.03)
+                return []
+
+        def pytest_collect_file(file_path, parent):
+            if file_path.name == "slow.case":
+                return SlowFile.from_parent(parent, path=file_path)
+        """
+    )
+    pytester.makefile(".case", slow="content")
+    pytester.makepyfile(
+        """
+        def test_runs():
+            print("TEST EXECUTED")
+        """
+    )
+
+    result = pytester.runpytest_inprocess(
+        "--collect-profile", "-q", "-s", plugins=[plugin]
+    )
+
+    result.assert_outcomes(passed=1)
+    output = result.stdout.str()
+    assert re.search(
+        r"(?m)^time\s+collector\s+node\n"
+        r"\d+\.\d{3}s\s+SlowFile\s+slow\.case$",
+        output,
+    )
+    assert re.search(r"(?m)^\d+\.\d{3}s\s+Module\s+\S+\.py$", output)
+    assert re.search(r"Total collection: \d+\.\d{3}s \| 1 items", output)
+    assert output.index("collect profile") < output.index("TEST EXECUTED")
+
+
+def test_terminal_report_treats_unexpected_nodeid_text_as_data(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    unexpected_nodeid = "$(touch terminal-side-effect).case"
+    side_effect = pytester.path / "terminal-side-effect"
+    (pytester.path / unexpected_nodeid).write_text("content\n", encoding="utf-8")
+    pytester.makeconftest(
+        f"""
+        import pytest
+
+        class UnexpectedFile(pytest.File):
+            def collect(self):
+                return []
+
+        def pytest_collect_file(file_path, parent):
+            if file_path.name == {unexpected_nodeid!r}:
+                return UnexpectedFile.from_parent(parent, path=file_path)
+        """
+    )
+    pytester.makepyfile("def test_passes(): pass")
+
+    result = pytester.runpytest_inprocess("--collect-profile", "-q", plugins=[plugin])
+
+    result.assert_outcomes(passed=1)
+    assert re.search(
+        rf"(?m)^\d+\.\d{{3}}s\s+UnexpectedFile\s+{re.escape(unexpected_nodeid)}$",
+        result.stdout.str(),
+    )
+    assert not side_effect.exists()
+
+
+def test_total_includes_collection_work_outside_collector_reports(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makeconftest(
+        """
+        import time
+
+        def pytest_collection_modifyitems(items):
+            time.sleep(0.03)
+        """
+    )
+    pytester.makepyfile("def test_passes(): pass")
+
+    result = pytester.runpytest_inprocess(
+        "--collect-profile", "--collect-only", "-q", plugins=[plugin]
+    )
+
+    assert result.ret == 0
+    result.stdout.fnmatch_lines(["*1 test collected*"])
+    output = result.stdout.str()
+    row_durations = [
+        float(value)
+        for value in re.findall(
+            r"(?m)^(\d+\.\d{3})s\s+\w+\s+(?:\S.*|<session>)$", output
+        )
+    ]
+    total_match = re.search(r"Total collection: (\d+\.\d{3})s", output)
+    assert row_durations
+    assert total_match is not None
+    assert float(total_match.group(1)) >= max(row_durations) + 0.02
+
+
+def test_collect_only_reports_without_executing_tests(pytester, monkeypatch) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    execution_marker = pytester.path / "test-executed"
+    pytester.makepyfile(
+        f"""
+        from pathlib import Path
+
+        def test_does_not_run():
+            Path({str(execution_marker)!r}).write_text("executed", encoding="utf-8")
+        """
+    )
+
+    result = pytester.runpytest_inprocess(
+        "--collect-profile", "--collect-only", "-q", plugins=[plugin]
+    )
+
+    assert result.ret == 0
+    result.stdout.fnmatch_lines(["*1 test collected*"])
+    assert "Total collection:" in result.stdout.str()
+    assert not execution_marker.exists()
+
+
+def test_profile_preserves_selection_and_collected_item_count(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makepyfile(
+        """
+        def test_selected():
+            print("SELECTED EXECUTED")
+
+        def test_not_selected():
+            print("UNSELECTED EXECUTED")
+        """
+    )
+
+    profiled = pytester.runpytest_inprocess(
+        "--collect-profile", "-q", "-s", "-k", "test_selected", plugins=[plugin]
+    )
+    unprofiled = pytester.runpytest_inprocess(
+        "-q", "-s", "-k", "test_selected", plugins=[plugin]
+    )
+
+    assert profiled.ret == unprofiled.ret == 0
+    assert (
+        profiled.parseoutcomes()
+        == unprofiled.parseoutcomes()
+        == {
+            "passed": 1,
+            "deselected": 1,
+        }
+    )
+    assert "Total collection:" in profiled.stdout.str()
+    assert "| 1 items" in profiled.stdout.str()
+    assert "collect profile" not in unprofiled.stdout.str()
+    for result in (profiled, unprofiled):
+        assert "SELECTED EXECUTED" in result.stdout.str()
+        assert "UNSELECTED EXECUTED" not in result.stdout.str()
+
+
+def test_profiled_empty_suite_preserves_native_no_tests_outcome(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+
+    profiled = pytester.runpytest_inprocess("--collect-profile", "-q", plugins=[plugin])
+    unprofiled = pytester.runpytest_inprocess("-q", plugins=[plugin])
+
+    assert profiled.ret == unprofiled.ret == 5
+    assert "Total collection:" in profiled.stdout.str()
+    assert "| 0 items" in profiled.stdout.str()
+    assert "collect profile" not in unprofiled.stdout.str()
+
+
+def test_collection_error_keeps_native_failure_and_exit_status(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makepyfile("import module_that_does_not_exist")
+
+    profiled = pytester.runpytest_inprocess("--collect-profile", "-q", plugins=[plugin])
+    unprofiled = pytester.runpytest_inprocess("-q", plugins=[plugin])
+
+    assert profiled.ret == unprofiled.ret == 2
+    for result in (profiled, unprofiled):
+        result.stdout.fnmatch_lines(["*ERROR collecting*"])
+        assert "ModuleNotFoundError" in result.stdout.str()
+        assert "1 error" in result.stdout.str()
+        assert "passed" not in result.stdout.str()
+    assert "Total collection:" in profiled.stdout.str()
+    assert "| 0 items" in profiled.stdout.str()
+    assert "collect profile" not in unprofiled.stdout.str()
+
+
+def test_failing_test_keeps_native_outcome_after_profile_report(
+    pytester, monkeypatch
+) -> None:
+    monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
+    pytester.makepyfile(
+        """
+        def test_fails():
+            assert False, "native failure"
+        """
+    )
+
+    profiled = pytester.runpytest_inprocess("--collect-profile", "-q", plugins=[plugin])
+    unprofiled = pytester.runpytest_inprocess("-q", plugins=[plugin])
+
+    assert profiled.ret == unprofiled.ret == 1
+    assert profiled.parseoutcomes() == unprofiled.parseoutcomes() == {"failed": 1}
+    for result in (profiled, unprofiled):
+        assert "native failure" in result.stdout.str()
+    output = profiled.stdout.str()
+    assert "Total collection:" in output
+    assert output.index("collect profile") < output.index("FAILURES")
+    assert "collect profile" not in unprofiled.stdout.str()