pytest-testrex 0.1.0__tar.gz

pytest_testrex-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luna White
+
+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_testrex-0.1.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: pytest-testrex
+Version: 0.1.0
+Summary: A pytest plugin that holds a test suite to one layout and one standard of test quality
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NearlyTRex/TestRex
+Project-URL: Issues, https://github.com/NearlyTRex/TestRex/issues
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=8
+Requires-Dist: pylint>=3
+Dynamic: license-file
+
+# TestRex
+
+[![CI](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml)
+[![Security](https://github.com/NearlyTRex/TestRex/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/NearlyTRex/TestRex/actions/workflows/security.yml)
+[![PyPI](https://img.shields.io/pypi/v/pytest-testrex)](https://pypi.org/project/pytest-testrex/)
+[![License](https://img.shields.io/github/license/NearlyTRex/TestRex)](LICENSE)
+
+A pytest plugin that holds a test suite to one layout and one standard of test quality
+
+My repos share one way of laying out and writing tests. This plugin carries the rules, so a repo
+gets them, and every fix to them, through one dependency bump instead of a copied meta suite.
+
+It does three things:
+
+- **The meta suite.** Around thirty rules that read every test file and fail on tests that cannot
+  fail, files in the wrong place, duplicated definitions and helpers, undeclared programs, broken
+  override signatures and pylint findings. There are no exemption lists: a test that trips a rule
+  is fixed.
+- **Required programs.** `requires_binary` (and any marker a repo adds) skips a test while
+  collecting, before any of its fixtures start, when a program it needs is missing.
+- **Hermetic runs.** Outbound network is closed to tests unless they are marked `allow_network`,
+  and the programs a repo seals (`sudo`, `ssh`, a password manager) are refused however a test
+  starts them.
+
+## Setting up a repo
+
+Install it with the test dependencies. With a hash-locked `requirements-dev.in`:
+
+```text
+pytest-testrex
+```
+
+Then opt in with a `[tool.testrex]` table in `pyproject.toml`. Without one the plugin does nothing,
+so having it installed never changes another project's run:
+
+```toml
+[tool.testrex]
+suites = ["unit", "integration"]
+```
+
+and run the meta suite by subclassing it in a test module under a meta directory, by default
+`Tests/unit/meta/`:
+
+```python
+# Tests/unit/meta/test_testrex.py
+from pytest_testrex import suite
+
+
+class TestRex(suite.TestRex):
+    """The suite's own rules, from pytest-testrex."""
+```
+
+The plugin parametrizes each rule over the files it reads, so a failure names the file:
+
+```text
+FAILED Tests/unit/meta/test_testrex.py::TestRex::test_every_test_checks_something[unit/pkg/test_mod.py]
+    asserts nothing: ['test_parse (line 12)']
+```
+
+## Layout
+
+Each suite mirrors the repository: a test lives at the path of the code it covers.
+
+```text
+pkg/strings.py                → Tests/unit/pkg/test_strings.py
+pkg/net/fetch.py              → Tests/unit/pkg/net/test_fetch.py
+scripts/setup.sh              → Tests/unit/scripts/test_setup.py
+.githooks/pre-commit          → Tests/unit/githooks/test_pre_commit.py
+pkg/net/fetch.py (real HTTP)  → Tests/integration/pkg/net/test_fetch.py
+```
+
+What decides the suite is whether a test needs a program outside the process, not whether it
+touches real files. A test that works in `tmp_path` with the code and its Python dependencies alone
+is a unit test; one that runs `git`, `docker` or `7zz` goes in `integration/` and declares it.
+
+A test file that outgrows `max_lines` becomes a directory of the same name, `test_<module>/`, holding
+`test_<area>.py` files, a `conftest.py` and a `<module>_helpers.py` they share. Because the tree
+mirrors the source, two suites can hold files with the same basename, so run pytest with
+`--import-mode=importlib`.
+
+## The rules
+
+| Area | A test file fails when |
+|---|---|
+| Discovery | fewer than `min_test_files` were found, or a suite holds none, so the rules would be guarding nothing |
+| Hygiene | a test, test method, helper or constant is defined twice; an import sits below the header; it is longer than `max_lines`; it holds no test |
+| Quality | a test checks nothing; every check sits in a branch, loop or try; an assertion is true by construction; it only checks `is not None` or `isinstance`; an `except` swallows silently; a raising callable is built from `(_ for _ in ()).throw()`; a helper is copied between files |
+| Layout | a split package holds no test modules, hides tests in a file pytest won't collect, covers no real module or has a single-file twin; a directory mirrors nothing in the repository |
+| Programs | a program is checked for at run time instead of by a marker; a marker names a program by anything but a string literal; a test uses a program fixture without declaring its programs; `subprocess` runs a program the file never declares; an integration file declares no program at all |
+| Signatures | an override in `signature_packages` renames, drops, reorders or changes the default of a parameter of the method it overrides |
+| Pylint | pylint reports anything in the tests, with the shipped rcfile or `pylint_rcfile`; the library breaks a `library_rules` rule |
+
+A check counts as an `assert`, a mock's `assert_*`, `pytest.fail`, a `pytest.raises` or
+`pytest.warns` block, or a call to a helper that makes one, including helpers imported by name from
+a `*_helpers.py` beside the test or above it.
+
+## Required programs
+
+```python
+pytestmark = pytest.mark.requires_binary("docker")       # whole module
+
+@pytest.mark.requires_binary("gpg", "xorriso|mkisofs")   # "a|b" takes either
+def test_sign_image(): ...
+```
+
+A repo with its own kind of requirement, such as tools it installs itself, names the marker in
+`requirement_markers` and says how to check it from its `conftest.py`:
+
+```python
+def pytest_testrex_requirement_checkers(config):
+    return {"requires_tool": lambda names: [f"{name} (tool)" for name in names if not installed(name)]}
+```
+
+## Settings
+
+Every path is relative to the directory holding `pyproject.toml`. A setting the plugin doesn't know,
+or one of the wrong type, stops the run.
+
+| Setting | Default | What it does |
+|---|---|---|
+| `tests_dir` | `"Tests"` | Where the suites live |
+| `suites` | `["unit", "integration"]` | The suites under `tests_dir` |
+| `integration_suites` | `["integration"]` | Suites whose files must declare the programs they need |
+| `meta_dirs` | `["unit/meta"]` | Directories that mirror nothing on purpose |
+| `data_dirs` | `[]` | Directories under `tests_dir` holding data, never read as tests |
+| `source_extensions` | `[".py", ".sh"]` | What a split `test_<name>/` package may cover besides a directory |
+| `max_lines` | `900` | The longest a test file may be |
+| `min_test_files` | `1` | Fewer test files means discovery is looking in the wrong place |
+| `requirement_markers` | `["requires_binary"]` | Markers that declare a needed program; any beyond `requires_binary` need a hook |
+| `fixture_programs` | `{}` | `{fixture: [programs]}` a test using the fixture must declare, beyond `shell_sandbox` and `shell_traced_env` |
+| `pylint_rcfile` | the shipped one | Pylint config for the tests |
+| `library_targets` | `[]` | Library paths held to `library_rules` |
+| `library_rules` | `["unspecified-encoding"]` | Pylint rules the library's own linter lacks |
+| `signature_packages` | `[]` | Packages whose overrides must keep their base method's signature |
+| `sealed_programs` | `[]` | Programs a test may never start for real |
+| `block_network` | `true` | Refuse in-process outbound connections unless a test is marked `allow_network` |
+
+## Developing
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install --require-hashes --no-deps -r requirements-dev.txt
+pip install --no-deps --no-build-isolation -e .
+pytest -q
+```
+
+The library is held to its own rules: `Tests/unit/meta/test_testrex.py` runs the suite over these
+tests, and `Tests/unit/pytest_testrex/test_suite.py` checks that a clean sample repository passes
+every rule and a broken one fails every rule. CI runs through
+[NearlyTRex/Workflows](https://github.com/NearlyTRex/Workflows) at 100% line and branch coverage.
+
+## Releasing
+
+Run **Prepare Release** from the Actions tab with `patch`, `minor`, `major` or an exact version. It
+opens a pull request bumping `pyproject.toml`; merging it tags the version, publishes a GitHub
+Release with the sdist and wheel, and publishes them to PyPI through trusted publishing from the
+`pypi` environment.

pytest_testrex-0.1.0/README.md

@@ -0,0 +1,158 @@
+# TestRex
+
+[![CI](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/NearlyTRex/TestRex/actions/workflows/ci.yml)
+[![Security](https://github.com/NearlyTRex/TestRex/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/NearlyTRex/TestRex/actions/workflows/security.yml)
+[![PyPI](https://img.shields.io/pypi/v/pytest-testrex)](https://pypi.org/project/pytest-testrex/)
+[![License](https://img.shields.io/github/license/NearlyTRex/TestRex)](LICENSE)
+
+A pytest plugin that holds a test suite to one layout and one standard of test quality
+
+My repos share one way of laying out and writing tests. This plugin carries the rules, so a repo
+gets them, and every fix to them, through one dependency bump instead of a copied meta suite.
+
+It does three things:
+
+- **The meta suite.** Around thirty rules that read every test file and fail on tests that cannot
+  fail, files in the wrong place, duplicated definitions and helpers, undeclared programs, broken
+  override signatures and pylint findings. There are no exemption lists: a test that trips a rule
+  is fixed.
+- **Required programs.** `requires_binary` (and any marker a repo adds) skips a test while
+  collecting, before any of its fixtures start, when a program it needs is missing.
+- **Hermetic runs.** Outbound network is closed to tests unless they are marked `allow_network`,
+  and the programs a repo seals (`sudo`, `ssh`, a password manager) are refused however a test
+  starts them.
+
+## Setting up a repo
+
+Install it with the test dependencies. With a hash-locked `requirements-dev.in`:
+
+```text
+pytest-testrex
+```
+
+Then opt in with a `[tool.testrex]` table in `pyproject.toml`. Without one the plugin does nothing,
+so having it installed never changes another project's run:
+
+```toml
+[tool.testrex]
+suites = ["unit", "integration"]
+```
+
+and run the meta suite by subclassing it in a test module under a meta directory, by default
+`Tests/unit/meta/`:
+
+```python
+# Tests/unit/meta/test_testrex.py
+from pytest_testrex import suite
+
+
+class TestRex(suite.TestRex):
+    """The suite's own rules, from pytest-testrex."""
+```
+
+The plugin parametrizes each rule over the files it reads, so a failure names the file:
+
+```text
+FAILED Tests/unit/meta/test_testrex.py::TestRex::test_every_test_checks_something[unit/pkg/test_mod.py]
+    asserts nothing: ['test_parse (line 12)']
+```
+
+## Layout
+
+Each suite mirrors the repository: a test lives at the path of the code it covers.
+
+```text
+pkg/strings.py                → Tests/unit/pkg/test_strings.py
+pkg/net/fetch.py              → Tests/unit/pkg/net/test_fetch.py
+scripts/setup.sh              → Tests/unit/scripts/test_setup.py
+.githooks/pre-commit          → Tests/unit/githooks/test_pre_commit.py
+pkg/net/fetch.py (real HTTP)  → Tests/integration/pkg/net/test_fetch.py
+```
+
+What decides the suite is whether a test needs a program outside the process, not whether it
+touches real files. A test that works in `tmp_path` with the code and its Python dependencies alone
+is a unit test; one that runs `git`, `docker` or `7zz` goes in `integration/` and declares it.
+
+A test file that outgrows `max_lines` becomes a directory of the same name, `test_<module>/`, holding
+`test_<area>.py` files, a `conftest.py` and a `<module>_helpers.py` they share. Because the tree
+mirrors the source, two suites can hold files with the same basename, so run pytest with
+`--import-mode=importlib`.
+
+## The rules
+
+| Area | A test file fails when |
+|---|---|
+| Discovery | fewer than `min_test_files` were found, or a suite holds none, so the rules would be guarding nothing |
+| Hygiene | a test, test method, helper or constant is defined twice; an import sits below the header; it is longer than `max_lines`; it holds no test |
+| Quality | a test checks nothing; every check sits in a branch, loop or try; an assertion is true by construction; it only checks `is not None` or `isinstance`; an `except` swallows silently; a raising callable is built from `(_ for _ in ()).throw()`; a helper is copied between files |
+| Layout | a split package holds no test modules, hides tests in a file pytest won't collect, covers no real module or has a single-file twin; a directory mirrors nothing in the repository |
+| Programs | a program is checked for at run time instead of by a marker; a marker names a program by anything but a string literal; a test uses a program fixture without declaring its programs; `subprocess` runs a program the file never declares; an integration file declares no program at all |
+| Signatures | an override in `signature_packages` renames, drops, reorders or changes the default of a parameter of the method it overrides |
+| Pylint | pylint reports anything in the tests, with the shipped rcfile or `pylint_rcfile`; the library breaks a `library_rules` rule |
+
+A check counts as an `assert`, a mock's `assert_*`, `pytest.fail`, a `pytest.raises` or
+`pytest.warns` block, or a call to a helper that makes one, including helpers imported by name from
+a `*_helpers.py` beside the test or above it.
+
+## Required programs
+
+```python
+pytestmark = pytest.mark.requires_binary("docker")       # whole module
+
+@pytest.mark.requires_binary("gpg", "xorriso|mkisofs")   # "a|b" takes either
+def test_sign_image(): ...
+```
+
+A repo with its own kind of requirement, such as tools it installs itself, names the marker in
+`requirement_markers` and says how to check it from its `conftest.py`:
+
+```python
+def pytest_testrex_requirement_checkers(config):
+    return {"requires_tool": lambda names: [f"{name} (tool)" for name in names if not installed(name)]}
+```
+
+## Settings
+
+Every path is relative to the directory holding `pyproject.toml`. A setting the plugin doesn't know,
+or one of the wrong type, stops the run.
+
+| Setting | Default | What it does |
+|---|---|---|
+| `tests_dir` | `"Tests"` | Where the suites live |
+| `suites` | `["unit", "integration"]` | The suites under `tests_dir` |
+| `integration_suites` | `["integration"]` | Suites whose files must declare the programs they need |
+| `meta_dirs` | `["unit/meta"]` | Directories that mirror nothing on purpose |
+| `data_dirs` | `[]` | Directories under `tests_dir` holding data, never read as tests |
+| `source_extensions` | `[".py", ".sh"]` | What a split `test_<name>/` package may cover besides a directory |
+| `max_lines` | `900` | The longest a test file may be |
+| `min_test_files` | `1` | Fewer test files means discovery is looking in the wrong place |
+| `requirement_markers` | `["requires_binary"]` | Markers that declare a needed program; any beyond `requires_binary` need a hook |
+| `fixture_programs` | `{}` | `{fixture: [programs]}` a test using the fixture must declare, beyond `shell_sandbox` and `shell_traced_env` |
+| `pylint_rcfile` | the shipped one | Pylint config for the tests |
+| `library_targets` | `[]` | Library paths held to `library_rules` |
+| `library_rules` | `["unspecified-encoding"]` | Pylint rules the library's own linter lacks |
+| `signature_packages` | `[]` | Packages whose overrides must keep their base method's signature |
+| `sealed_programs` | `[]` | Programs a test may never start for real |
+| `block_network` | `true` | Refuse in-process outbound connections unless a test is marked `allow_network` |
+
+## Developing
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install --require-hashes --no-deps -r requirements-dev.txt
+pip install --no-deps --no-build-isolation -e .
+pytest -q
+```
+
+The library is held to its own rules: `Tests/unit/meta/test_testrex.py` runs the suite over these
+tests, and `Tests/unit/pytest_testrex/test_suite.py` checks that a clean sample repository passes
+every rule and a broken one fails every rule. CI runs through
+[NearlyTRex/Workflows](https://github.com/NearlyTRex/Workflows) at 100% line and branch coverage.
+
+## Releasing
+
+Run **Prepare Release** from the Actions tab with `patch`, `minor`, `major` or an exact version. It
+opens a pull request bumping `pyproject.toml`; merging it tags the version, publishes a GitHub
+Release with the sdist and wheel, and publishes them to PyPI through trusted publishing from the
+`pypi` environment.

pytest_testrex-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-testrex"
+version = "0.1.0"
+description = "A pytest plugin that holds a test suite to one layout and one standard of test quality"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = [
+    "pytest>=8",
+    "pylint>=3",
+]
+classifiers = [
+    "Framework :: Pytest",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+Homepage = "https://github.com/NearlyTRex/TestRex"
+Issues = "https://github.com/NearlyTRex/TestRex/issues"
+
+[project.entry-points.pytest11]
+testrex = "pytest_testrex.plugin"
+
+[tool.setuptools]
+packages = ["pytest_testrex"]
+
+[tool.setuptools.package-data]
+pytest_testrex = ["pylintrc"]
+
+[tool.pytest.ini_options]
+testpaths = ["Tests"]
+# The tree mirrors the source, so unit/ and any later suite can hold files
+# with the same basename, which the default prepend mode cannot import apart
+addopts = "--strict-markers -ra --import-mode=importlib -p pytester"
+
+[tool.coverage.run]
+branch = true
+source = ["pytest_testrex"]
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.testrex]
+suites = ["unit"]
+integration_suites = []
+meta_dirs = ["unit/meta"]
+# The meta suite runs over sample trees written by the tests themselves
+min_test_files = 10
+signature_packages = ["pytest_testrex"]
+library_targets = ["pytest_testrex"]
+sealed_programs = ["sudo", "ssh"]

pytest_testrex-0.1.0/pytest_testrex/__init__.py

@@ -0,0 +1 @@
+"""Hold a test suite to one layout and one standard of test quality."""

pytest_testrex-0.1.0/pytest_testrex/discovery.py

@@ -0,0 +1,151 @@
+# Imports
+import ast
+import functools
+import os
+
+###########################################################
+# The suites under test
+#
+# The meta suite reads every file under the suites and holds it to one
+# standard. It only parses; nothing here imports a test.
+###########################################################
+
+FUNCTION_DEFS = (ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def is_ignored(path, ignored_dirs):
+    return any(path == directory or path.startswith(directory + os.sep) for directory in ignored_dirs)
+
+
+# Every test_*.py under the suites, or with test_modules_only off every .py
+def discover_python_files(suite_dirs, test_modules_only, ignored_dirs = ()):
+    found = []
+    for suite_dir in suite_dirs:
+        for root, dirs, files in os.walk(suite_dir):
+            dirs[:] = [name for name in dirs if name != "__pycache__" and not is_ignored(os.path.join(root, name), ignored_dirs)]
+            for name in files:
+                if name.endswith(".py") and (not test_modules_only or name.startswith("test_")):
+                    found.append(os.path.join(root, name))
+    return sorted(found)
+
+
+@functools.lru_cache(maxsize = None)
+def parsed(path):
+    with open(path, "r", encoding = "utf-8") as handle:
+        return ast.parse(handle.read())
+
+
+def is_test_function(node):
+    return isinstance(node, FUNCTION_DEFS) and node.name.startswith("test_")
+
+
+def is_test_class(node):
+    return isinstance(node, ast.ClassDef) and node.name.startswith("Test")
+
+
+# Every test pytest would collect from this module's own definitions: module
+# level, or a method of a Test class
+def collected_tests(tree):
+    found = [node for node in tree.body if is_test_function(node)]
+    for node in tree.body:
+        if is_test_class(node):
+            found.extend(member for member in node.body if is_test_function(member))
+    return found
+
+
+# Whether a module defines tests, including a Test class that only inherits them
+def defines_tests(tree):
+    return any(is_test_function(node) or is_test_class(node) for node in tree.body)
+
+
+def parameter_names(function):
+    arguments = function.args
+    return [argument.arg for argument in arguments.posonlyargs + arguments.args + arguments.kwonlyargs]
+
+
+def is_fixture(function):
+    return any("fixture" in ast.unparse(decorator) for decorator in function.decorator_list)
+
+###########################################################
+# Checks
+#
+# What makes a test fail when its expectation is not met: an assert, a mock's
+# or recorder's assert_*, pytest.fail, a pytest.raises / warns block, or a
+# call to a helper that itself makes checks. Helpers are often imported by
+# name from a *_helpers.py beside the test, so those are followed too.
+###########################################################
+
+def is_raises_block(node):
+    return isinstance(node, ast.With) and any(
+        any(word in ast.unparse(item.context_expr) for word in ("raises", "warns"))
+        for item in node.items)
+
+
+def is_check_call(node, checkers = frozenset()):
+    if not isinstance(node, ast.Call):
+        return False
+    name = ast.unparse(node.func)
+    last = name.rsplit(".", maxsplit = 1)[-1]
+    return last.startswith("assert") or name.endswith("pytest.fail") or last in checkers
+
+
+# Checks reachable in statements without entering a node of a type in stop_at.
+# A try/finally with no handler runs its body straight through, so it is not a branch.
+def checks_in(statements, stop_at = (), checkers = frozenset()):
+    found = []
+
+    def visit(node):
+        if isinstance(node, stop_at) and not (isinstance(node, ast.Try) and not node.handlers):
+            return
+        if isinstance(node, ast.Assert) or is_check_call(node, checkers) or is_raises_block(node):
+            found.append(node)
+        for child in ast.iter_child_nodes(node):
+            visit(child)
+    for statement in statements:
+        visit(statement)
+    return found
+
+
+# Where a module imported by name from path lives: beside it, in a directory
+# above it within tests_dir, or at the top of tests_dir
+def find_helper_module(path, module_name, tests_dir):
+    directory = os.path.dirname(path)
+    while True:
+        candidate = os.path.join(directory, module_name.replace(".", os.sep) + ".py")
+        if os.path.isfile(candidate):
+            return candidate
+        if directory == tests_dir or not directory.startswith(tests_dir):
+            return None
+        directory = os.path.dirname(directory)
+
+
+# Names of the functions defined in tree that make checks, directly or through
+# another such function, given the checker names it can already see
+def local_checkers(tree, known = frozenset()):
+    functions = [node for node in ast.walk(tree) if isinstance(node, FUNCTION_DEFS) and not node.name.startswith("test_")]
+    checkers = set()
+    while True:
+        visible = frozenset(known | checkers)
+        found = {function.name for function in functions if checks_in(function.body, (), visible)}
+        if found <= checkers:
+            return frozenset(checkers)
+        checkers |= found
+
+
+# Every name a call in path can use to reach a checking helper
+@functools.lru_cache(maxsize = None)
+def checker_names(path, tests_dir, seen = frozenset()):
+    tree = parsed(path)
+    imported = set()
+    for node in tree.body:
+        if isinstance(node, ast.ImportFrom) and node.module and not node.level:
+            helper = find_helper_module(path, node.module, tests_dir)
+            if helper and helper not in seen:
+                theirs = checker_names(helper, tests_dir, seen | {path})
+                imported.update(alias.asname or alias.name for alias in node.names if alias.name in theirs)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                helper = find_helper_module(path, alias.name, tests_dir)
+                if helper and helper not in seen:
+                    imported.update(checker_names(helper, tests_dir, seen | {path}))
+    return local_checkers(tree, frozenset(imported)) | frozenset(imported)

pytest_testrex-0.1.0/pytest_testrex/hookspecs.py

@@ -0,0 +1,15 @@
+# Third-party imports
+import pytest
+
+# Hooks a repository's conftest.py can implement
+
+
+@pytest.hookspec
+def pytest_testrex_requirement_checkers(config):
+    """Return {marker name: check} for requirement markers beyond requires_binary.
+
+    Each check takes the names a test's markers list and returns a label for
+    each one that is unavailable, such as "XorrISO (JoyBox tool)". A test with
+    any unavailable name is skipped while collecting, before its fixtures run.
+    Every marker in [tool.testrex] requirement_markers needs a check.
+    """

pytest_testrex-0.1.0/pytest_testrex/hygiene.py

@@ -0,0 +1,59 @@
+# Imports
+import ast
+import collections
+
+# Local imports
+from pytest_testrex.discovery import FUNCTION_DEFS, is_test_function
+
+###########################################################
+# File hygiene
+#
+# A test defined twice in one file silently replaces the first, which then
+# never runs again and reports nothing when it would have failed. Large files
+# are where this happens, so they are also kept to a size where it stays
+# visible.
+###########################################################
+
+def duplicated(names):
+    return sorted(name for name, count in collections.Counter(names).items() if count > 1)
+
+
+def duplicate_tests(tree):
+    return duplicated(node.name for node in tree.body if is_test_function(node))
+
+
+# {class: names} for test methods defined twice within one class
+def duplicate_test_methods(tree):
+    return {
+        node.name: names for node in tree.body if isinstance(node, ast.ClassDef)
+        for names in [duplicated(member.name for member in node.body if is_test_function(member))]
+        if names}
+
+
+def duplicate_definitions(tree):
+    return duplicated(node.name for node in tree.body if isinstance(node, FUNCTION_DEFS + (ast.ClassDef,)))
+
+
+def duplicate_constants(tree):
+    return duplicated(
+        target.id for node in tree.body if isinstance(node, ast.Assign)
+        for target in node.targets if isinstance(target, ast.Name) and target.id.isupper())
+
+
+# Lines of imports that come after the first real statement
+def late_imports(tree):
+    first_statement = None
+    late = []
+    for node in tree.body:
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            if first_statement is not None:
+                late.append(node.lineno)
+        elif not (isinstance(node, ast.Expr) and isinstance(node.value, ast.Constant)):
+            if first_statement is None:
+                first_statement = node.lineno
+    return late
+
+
+def line_count(path):
+    with open(path, "r", encoding = "utf-8") as handle:
+        return sum(1 for _ in handle)