habit-hooks-python 1.4.0rc1__tar.gz → 1.4.0rc2__tar.gz

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: habit-hooks-python
-Version: 1.4.0rc1
+Version: 1.4.0rc2
 Summary: The Python Habit Hooks plugin
 Project-URL: Homepage, https://habit-hooks.com
 Project-URL: Repository, https://github.com/habit-hooks/habit-hooks

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/docs/python-plugin.spec.md

@@ -337,7 +337,7 @@ habit-sensors --all 2>&1 >/dev/null | sed -n 1p
 
 🖥️ ❌ 1
 ```text
-habit-sensors: sensor 'deptry' failed: '${python}' '${dir}/deptry_sensor.py'
+habit-sensors: sensor 'deptry' failed: '${python}' '${dir}/deptry_sensor.py' '${detector:deptry}'
 ```
 
 ## A crashing ruff fails the run, never reports clean
@@ -388,5 +388,5 @@ habit-sensors --all 2>&1 >/dev/null | sed -n 1p
 
 🖥️ ❌ 1
 ```text
-habit-sensors: sensor 'ruff' failed: '${python}' '${dir}/ruff_sensor.py' '${files}'
+habit-sensors: sensor 'ruff' failed: '${python}' '${dir}/ruff_sensor.py' '${detector:ruff}' '${files}'
 ```

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "habit-hooks-python"
-version = "1.4.0rc1"
+version = "1.4.0rc2"
 description = "The Python Habit Hooks plugin"
 readme = "README.md"
 license = "MIT"

habit_hooks_python-1.4.0rc2/src/habit_hooks_python/sensors/deptry.toml

@@ -0,0 +1 @@
+argv = ["${python}", "${dir}/deptry_sensor.py", "${detector:deptry}"]

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/src/habit_hooks_python/sensors/deptry_sensor.py

@@ -13,28 +13,23 @@ import sys
 import tempfile
 from pathlib import Path
 
-from tool_spawn import run_tool
 
+def run_deptry(deptry: str, report: Path) -> subprocess.CompletedProcess[str]:
+    """What deptry said, spawned as the file this sensor was handed for it.
 
-def run_deptry(report: Path) -> subprocess.CompletedProcess[str]:
-    """What deptry said, or what a shell says about a deptry nobody installed.
-
-    ``pip install habit-hooks-python`` brings neither detector with it, so this
-    is the ordinary state of a machine that has just enabled the plugin — and an
-    absent tool raised a ``FileNotFoundError`` out of here, making twenty lines
-    of Python internals the sensor's diagnosis (#114). This wrapper is what looks
-    for deptry, so it answers the way the shell would have, and that phrase is
-    what the run recognises to name the missing tool. Looking is ``tool_spawn``'s,
-    which names the file — a console script a project's own venv installed, which
-    Windows spells ``deptry.exe`` there and habit-hooks' venv may not hold at all.
+    ``sensors/deptry.toml`` names ``${detector:deptry}``, so the run resolves
+    deptry to a file before this helper starts and passes it as the first
+    argument — a console script the project's own venv installed, which
+    habit-hooks' venv may not hold at all and Windows spells ``deptry.exe``. A
+    deptry nobody installed never reaches here: the run answers for it as the
+    missing command it is, in one line rather than a traceback (#114).
     """
-    command = ["deptry", ".", "--json-output", str(report)]
-    try:
-        return run_tool(command)
-    except FileNotFoundError:
-        return subprocess.CompletedProcess(
-            command, 127, "", "deptry: command not found\n"
-        )
+    return subprocess.run(
+        [deptry, ".", "--json-output", str(report)],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
 
 
 def deptry_crashed(result: subprocess.CompletedProcess[str], report: Path) -> bool:
@@ -85,9 +80,10 @@ def findings(entries: list[dict]) -> list[dict]:
 
 
 def main() -> int:
+    deptry = sys.argv[1]
     with tempfile.TemporaryDirectory() as tmp:
         report = Path(tmp) / "deptry-report.json"
-        result = run_deptry(report)
+        result = run_deptry(deptry, report)
         if deptry_crashed(result, report):
             if deptry_found_no_declaration(result):
                 print(json.dumps([]))

habit_hooks_python-1.4.0rc2/src/habit_hooks_python/sensors/ruff.toml

@@ -0,0 +1 @@
+argv = ["${python}", "${dir}/ruff_sensor.py", "${detector:ruff}", "${files}"]

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/src/habit_hooks_python/sensors/ruff_sensor.py

@@ -24,8 +24,6 @@ import json
 import subprocess
 import sys
 
-from tool_spawn import run_tool
-
 SELECTED_CODES = "C901,PLR0913,PLR0915,F841,F401,BLE001"
 
 CODE_SMELLS = {
@@ -45,32 +43,21 @@ CODE_SMELLS = {
 TOOL_EXIT_CODES = (0, 1)
 
 
-def run_ruff(files: list[str]) -> subprocess.CompletedProcess[str]:
-    """What ruff said, or what a shell says about a ruff nobody installed.
+def run_ruff(ruff: str, files: list[str]) -> subprocess.CompletedProcess[str]:
+    """What ruff said, spawned as the file this sensor was handed for it.
 
-    ``pip install habit-hooks-python`` brings neither wrapped tool with it, so
-    this is the ordinary state of a machine that has just enabled the plugin —
-    and an absent tool raised a ``FileNotFoundError`` out of here, making
-    twenty lines of Python internals the sensor's diagnosis (#114). This
-    wrapper is what looks for ruff, so it answers the way the shell would
-    have, and that phrase is what the run recognises to name the missing
-    tool. Looking is ``tool_spawn``'s, which names the file — ``ruff.exe`` or
-    a ``.cmd`` shim on Windows, neither of which a bare ``["ruff", ...]``
-    spawn reliably reaches there.
+    ``sensors/ruff.toml`` names ``${detector:ruff}``, so the run resolves ruff
+    to a file before this helper starts and passes it as the first argument —
+    the ``ruff.exe`` a bare ``["ruff", ...]`` spawn misses on Windows. A ruff
+    nobody installed never reaches here at all: the run answers for it as the
+    missing command it is, in one line rather than a traceback (#114).
     """
-    command = [
-        "ruff",
-        "check",
-        "--output-format=json",
-        f"--select={SELECTED_CODES}",
-        *files,
-    ]
-    try:
-        return run_tool(command)
-    except FileNotFoundError:
-        return subprocess.CompletedProcess(
-            command, 127, "", "ruff: command not found\n"
-        )
+    return subprocess.run(
+        [ruff, "check", "--output-format=json", f"--select={SELECTED_CODES}", *files],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
 
 
 def ruff_crashed(result: subprocess.CompletedProcess[str]) -> bool:
@@ -113,8 +100,9 @@ def findings(entries: list[dict]) -> list[dict]:
 
 
 def main() -> int:
-    files = sys.argv[1:]
-    result = run_ruff(files)
+    ruff = sys.argv[1]
+    files = sys.argv[2:]
+    result = run_ruff(ruff, files)
     if ruff_crashed(result):
         sys.stderr.write(result.stderr)
         return 2

habit_hooks_python-1.4.0rc2/tests/conftest.py

@@ -0,0 +1,56 @@
+"""What every test here needs of the run it stands in for.
+
+**A helper loads as a loose script.** The sensor specs spell
+``${python} ${dir}/<helper>.py``, so the interpreter puts the helper's own
+directory first on ``sys.path``, and a unit test does the same rather than
+reaching the code as ``habit_hooks_python.sensors.ruff_sensor`` — a load path no
+run ever takes (see "A plugin helper imports its neighbours as top-level
+modules" in CLAUDE.md).
+
+**A helper is handed its tool as a file.** The specs name theirs with
+``${detector:<tool>}``, which the run resolves against the project's own bins
+before the helper is spawned (``project_paths.tool_executable``). A test
+spawning a helper directly stands in for the run, so it asks that same question
+and hands over a real file rather than a name. Absent is a failure rather than a
+skip: ``uv sync`` brings both, so a machine without one is a suite that has
+quietly stopped gating.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+SENSORS = (
+    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
+)
+
+sys.path.insert(0, str(SENSORS))
+
+
+@pytest.fixture(scope="session")
+def ruff() -> str:
+    """The file this machine runs ruff by, as the sensor's first argument."""
+    return _installed("ruff")
+
+
+@pytest.fixture(scope="session")
+def deptry() -> str:
+    """The file this machine runs deptry by, as the sensor's first argument."""
+    return _installed("deptry")
+
+
+def _installed(tool: str) -> str:
+    """The file this machine runs ``tool`` by.
+
+    ``shutil.which`` rather than the name on disk: a console script is
+    ``<tool>.exe`` in a Windows venv, which a lookup finds and a spawn handed
+    the bare name cannot reach.
+    """
+    found = shutil.which(tool)
+    if found is None:
+        pytest.fail(f"{tool} is not on PATH — run 'uv sync'")
+    return found

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/tests/test_a_crashing_ruff_fails_the_run.py

@@ -36,14 +36,14 @@ def test_any_other_exit_code_is_a_crash(returncode: int) -> None:
     assert ruff_crashed(_result(returncode)) is True
 
 
-def test_a_broken_ruff_toml_fails_the_run(tmp_path: Path) -> None:
+def test_a_broken_ruff_toml_fails_the_run(tmp_path: Path, ruff: str) -> None:
     (tmp_path / "ruff.toml").write_text(
         "this is not = valid ruff config\n", encoding="utf-8"
     )
     (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
-        [sys.executable, str(SENSOR), "app.py"],
+        [sys.executable, str(SENSOR), ruff, "app.py"],
         cwd=tmp_path,
         capture_output=True,
         encoding="utf-8",

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/tests/test_a_project_declaring_no_dependencies_is_clean.py

@@ -24,11 +24,13 @@ SENSOR = (
 )
 
 
-def test_a_project_declaring_no_dependencies_is_a_clean_run(tmp_path: Path) -> None:
+def test_a_project_declaring_no_dependencies_is_a_clean_run(
+    tmp_path: Path, deptry: str
+) -> None:
     (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
-        [sys.executable, str(SENSOR)],
+        [sys.executable, str(SENSOR), deptry],
         cwd=tmp_path,
         capture_output=True,
         encoding="utf-8",
@@ -41,14 +43,14 @@ def test_a_project_declaring_no_dependencies_is_a_clean_run(tmp_path: Path) -> N
 
 
 def test_deptry_still_answers_a_missing_declaration_with_that_error(
-    tmp_path: Path,
+    tmp_path: Path, deptry: str
 ) -> None:
     """The sensor recognises deptry's exception by name, so a deptry that stops
     raising it must fail here rather than silently retire that branch."""
     (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
-        ["deptry", "."],
+        [deptry, "."],
         cwd=tmp_path,
         capture_output=True,
         encoding="utf-8",
@@ -58,7 +60,9 @@ def test_deptry_still_answers_a_missing_declaration_with_that_error(
     assert "DependencySpecificationNotFoundError" in result.stderr
 
 
-def test_deptry_failing_another_way_still_fails_the_run(tmp_path: Path) -> None:
+def test_deptry_failing_another_way_still_fails_the_run(
+    tmp_path: Path, deptry: str
+) -> None:
     (tmp_path / "pyproject.toml").write_text(
         '[project]\nname = "demo"\nversion = "0.0.0"\ndependencies = []\n\n'
         "[tool.deptry]\nnot_a_real_option = true\n",
@@ -67,7 +71,7 @@ def test_deptry_failing_another_way_still_fails_the_run(tmp_path: Path) -> None:
     (tmp_path / "app.py").write_text("import os\n", encoding="utf-8")
 
     result = subprocess.run(
-        [sys.executable, str(SENSOR)],
+        [sys.executable, str(SENSOR), deptry],
         cwd=tmp_path,
         capture_output=True,
         encoding="utf-8",

habit_hooks_python-1.4.0rc2/tests/test_a_sensor_spawns_the_tool_it_was_handed.py

@@ -0,0 +1,78 @@
+"""A sensor spawns the tool it was handed, never a name it looks up again.
+
+``sensors/ruff.toml`` and ``sensors/deptry.toml`` each name their tool with
+``${detector:<name>}``, so the run resolves it to a file and passes that file as
+the helper's first argument. Handing over the file is the whole point: a bare
+name is looked up again by whatever spawns it, and Windows' own lookup adds
+``.exe`` and nothing else — where a project's venv holds ``deptry.exe`` and npm
+installs a Node tool as a ``.cmd`` shim.
+
+A ``PATH`` that cannot answer the tool's own name is what proves the helper
+takes it: a helper still spelling that name would find nothing to spawn, while
+one handed the file runs a tool no search path leads to.
+
+A tool nobody installed is no longer this plugin's to answer for. The run
+resolves the name before the helper is spawned and answers for an absent one
+itself, as the ordinary missing command it is
+(``tests/test_a_tool_a_part_cannot_run.py``).
+"""
+
+from __future__ import annotations
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from tool_lookup import where_the_bare_name_reaches_nothing
+
+SENSORS = (
+    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
+)
+
+
+def _run(
+    helper: str, tool: str, project: Path, *arguments: str
+) -> subprocess.CompletedProcess[str]:
+    """The helper's own run, where nothing answers the tool's bare name."""
+    return subprocess.run(
+        [sys.executable, str(SENSORS / helper), *arguments],
+        cwd=project,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+        env=where_the_bare_name_reaches_nothing(tool),
+    )
+
+
+def test_the_ruff_sensor_spawns_the_ruff_it_was_handed(
+    tmp_path: Path, ruff: str
+) -> None:
+    (tmp_path / "billing.py").write_text("import os\n", encoding="utf-8")
+
+    result = _run("ruff_sensor.py", "ruff", tmp_path, ruff, "billing.py")
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert [finding["smell"] for finding in json.loads(result.stdout)] == [
+        "unused-import"
+    ]
+
+
+def test_the_deptry_sensor_spawns_the_deptry_it_was_handed(
+    tmp_path: Path, deptry: str
+) -> None:
+    (tmp_path / "pyproject.toml").write_text(
+        '[project]\nname = "demo"\nversion = "0.0.0"\ndependencies = ["rich"]\n',
+        encoding="utf-8",
+    )
+    (tmp_path / "app.py").write_text(
+        "def fetch(url):\n    return url\n", encoding="utf-8"
+    )
+
+    result = _run("deptry_sensor.py", "deptry", tmp_path, deptry)
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert [finding["smell"] for finding in json.loads(result.stdout)] == [
+        "unused-dependency"
+    ]

{habit_hooks_python-1.4.0rc1 → habit_hooks_python-1.4.0rc2}/tests/test_the_ruff_sensor_runs_the_real_tool.py

@@ -18,9 +18,9 @@ SENSOR = (
 )
 
 
-def _run(project: Path, *files: str) -> subprocess.CompletedProcess[str]:
+def _run(project: Path, ruff: str, *files: str) -> subprocess.CompletedProcess[str]:
     return subprocess.run(
-        [sys.executable, str(SENSOR), *files],
+        [sys.executable, str(SENSOR), ruff, *files],
         cwd=project,
         capture_output=True,
         encoding="utf-8",
@@ -28,23 +28,25 @@ def _run(project: Path, *files: str) -> subprocess.CompletedProcess[str]:
     )
 
 
-def test_a_clean_file_is_a_clean_run(tmp_path: Path) -> None:
+def test_a_clean_file_is_a_clean_run(tmp_path: Path, ruff: str) -> None:
     (tmp_path / "clean.py").write_text("def add(a, b):\n    return a + b\n", encoding="utf-8")
 
-    result = _run(tmp_path, "clean.py")
+    result = _run(tmp_path, ruff, "clean.py")
 
     assert result.returncode == 0
     assert result.stderr == ""
     assert json.loads(result.stdout) == []
 
 
-def test_a_real_violation_comes_out_as_the_mapped_smell(tmp_path: Path) -> None:
+def test_a_real_violation_comes_out_as_the_mapped_smell(
+    tmp_path: Path, ruff: str
+) -> None:
     (tmp_path / "billing.py").write_text(
         "import os\n\n\ndef charge():\n    unused = 1\n    return 0\n",
         encoding="utf-8",
     )
 
-    result = _run(tmp_path, "billing.py")
+    result = _run(tmp_path, ruff, "billing.py")
 
     assert result.returncode == 0
     findings = json.loads(result.stdout)
@@ -54,10 +56,10 @@ def test_a_real_violation_comes_out_as_the_mapped_smell(tmp_path: Path) -> None:
     }
 
 
-def test_ruff_maps_a_syntax_error_to_parse_error(tmp_path: Path) -> None:
+def test_ruff_maps_a_syntax_error_to_parse_error(tmp_path: Path, ruff: str) -> None:
     (tmp_path / "broken.py").write_text("def broken(:\n    return 1\n", encoding="utf-8")
 
-    result = _run(tmp_path, "broken.py")
+    result = _run(tmp_path, ruff, "broken.py")
 
     assert result.returncode == 0
     findings = json.loads(result.stdout)

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/deptry.toml

@@ -1 +0,0 @@
-argv = ["${python}", "${dir}/deptry_sensor.py"]

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/ruff.toml

@@ -1 +0,0 @@
-argv = ["${python}", "${dir}/ruff_sensor.py", "${files}"]

habit_hooks_python-1.4.0rc1/src/habit_hooks_python/sensors/tool_spawn.py

@@ -1,77 +0,0 @@
-"""Spawn the third-party tool a sensor wraps, by the file rather than the name.
-
-A local copy of what ``habit_hooks/sensors/spawn.py`` and its ``batch_shell`` do
-for a part's own argv, and it is a copy on purpose: this plugin declares no
-dependency on ``habit-hooks``, so a helper cannot import the core, and four
-small copies beat a dependency that does not exist. The core's modules carry the
-full reasoning; the two rules are Windows' own.
-
-**A bare name is looked up first.** Windows' spawn appends ``.exe`` to a name and
-nothing else, so the ``jscpd.CMD`` npm installs and the ``pmd.bat`` PMD ships are
-found by a lookup and then unreachable by a spawn handed the name — the tool the
-setup cleared, reported missing by the run. This is not a second answer to that
-question: habit-hooks hands a helper a ``PATH`` of the project's own bins
-(``sensors/spawn._path_env``), so ``shutil.which`` here asks exactly what cleared
-the tool, along exactly the same path.
-
-**A batch file's arguments are then ``cmd.exe``'s syntax.** ``CreateProcess``
-runs a ``.bat`` or ``.cmd`` through that shell, which reads ``&``, ``|``, ``<``,
-``>``, ``^``, ``"``, ``%VAR%`` and a newline as its own (CVE-2024-24576; CPython
-closed its half in 3.11.9, and ``>=3.11`` is supported). A sensor's arguments are
-paths out of the work tree, so one is refused rather than escaped: no tool anyone
-wraps needs those characters, and refusing needs no interpreter version to be
-right.
-"""
-
-from __future__ import annotations
-
-import shutil
-import subprocess
-
-BATCH_SUFFIXES = (".bat", ".cmd")
-
-# Everything ``cmd.exe`` reads as other than text: the separators and pipe, both
-# redirections, its own escape character, the quote that ends a quoted run, the
-# ``%`` that opens a variable, and the newline that ends the line it is reading.
-CMD_SYNTAX = frozenset('&|<>^"%\n\r')
-
-# Found, and refused rather than run — the code a shell keeps for a command it
-# located and would not execute, and outside every wrapped tool's success set.
-REFUSED_EXIT = 126
-
-
-def run_tool(command: list[str]) -> subprocess.CompletedProcess[str]:
-    """What ``command`` said, spawned as the file this project runs for its name.
-
-    A name reaching no file is spawned as it stands, so the caller's own
-    ``FileNotFoundError`` remains the single answer for a tool nobody installed.
-    """
-    program = shutil.which(command[0]) or command[0]
-    unreadable = cmd_syntax(program, command[1:])
-    if unreadable is not None:
-        return subprocess.CompletedProcess(
-            command,
-            REFUSED_EXIT,
-            "",
-            f"{program}: cannot pass {unreadable!r} to a batch file — cmd.exe "
-            "would read it as its own syntax rather than as text\n",
-        )
-    return subprocess.run(
-        [program, *command[1:]],
-        capture_output=True,
-        encoding="utf-8",
-        errors="replace",  # sensors.spawn's policy
-    )
-
-
-def cmd_syntax(program: str, arguments: list[str]) -> str | None:
-    """The first of ``arguments`` ``cmd.exe`` would read as syntax, if it reads any.
-
-    ``None`` where ``program`` is not a batch file: nothing then stands between
-    the spawn and the program, and an ``&`` in a filename is a filename.
-    """
-    if not program.lower().endswith(BATCH_SUFFIXES):
-        return None
-    return next(
-        (argument for argument in arguments if CMD_SYNTAX & set(argument)), None
-    )

habit_hooks_python-1.4.0rc1/tests/conftest.py

@@ -1,20 +0,0 @@
-"""Load the ruff sensor the way it is actually run — as a loose script.
-
-The sensor spec spells ``${python} ${dir}/ruff_sensor.py``, so the
-interpreter puts the helper's own directory first on ``sys.path`` and a unit
-test does the same rather than reaching the code as
-``habit_hooks_python.sensors.ruff_sensor`` — a load path no run ever takes
-(see "A plugin helper imports its neighbours as top-level modules" in
-CLAUDE.md).
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-SENSORS = (
-    Path(__file__).resolve().parents[1] / "src" / "habit_hooks_python" / "sensors"
-)
-
-sys.path.insert(0, str(SENSORS))

habit_hooks_python-1.4.0rc1/tests/test_a_deptry_nobody_installed_is_named.py

@@ -1,36 +0,0 @@
-"""A detector this plugin does not bring with it must still answer in one line.
-
-``pip install habit-hooks-python`` installs neither ruff nor deptry, so a machine
-that has just enabled the plugin is the ordinary case, not the edge one. The ruff
-sensor is a shell command, so the shell answers for it; deptry is spawned from
-Python, where an absent tool is a ``FileNotFoundError`` and twenty lines of
-internals would otherwise become the sensor's diagnosis (#114).
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-SENSOR = (
-    Path(__file__).resolve().parents[1]
-    / "src/habit_hooks_python/sensors/deptry_sensor.py"
-)
-
-
-def test_a_deptry_nobody_installed_answers_the_way_a_shell_does(
-    tmp_path: Path,
-) -> None:
-    result = subprocess.run(
-        [sys.executable, str(SENSOR)],
-        cwd=tmp_path,
-        capture_output=True,
-        encoding="utf-8",
-        errors="replace",
-        env={"PATH": "/nonexistent"},
-    )
-
-    assert result.returncode != 0
-    assert result.stdout.strip() == ""
-    assert result.stderr.strip() == "deptry: command not found"

habit_hooks_python-1.4.0rc1/tests/test_a_ruff_nobody_installed_is_named.py

@@ -1,35 +0,0 @@
-"""A detector this plugin does not bring with it must still answer in one line.
-
-``pip install habit-hooks-python`` installs neither ruff nor deptry, so a machine
-that has just enabled the plugin is the ordinary case, not the edge one. ruff is
-spawned from Python now (it used to be a shell recipe, so the shell answered for
-it), and an absent tool is a ``FileNotFoundError`` — twenty lines of internals
-would otherwise become the sensor's diagnosis (#114). Mirrors
-``test_a_deptry_nobody_installed_is_named.py``.
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-SENSOR = (
-    Path(__file__).resolve().parents[1]
-    / "src/habit_hooks_python/sensors/ruff_sensor.py"
-)
-
-
-def test_a_ruff_nobody_installed_answers_the_way_a_shell_does(tmp_path: Path) -> None:
-    result = subprocess.run(
-        [sys.executable, str(SENSOR)],
-        cwd=tmp_path,
-        capture_output=True,
-        encoding="utf-8",
-        errors="replace",
-        env={"PATH": "/nonexistent"},
-    )
-
-    assert result.returncode == 2
-    assert result.stdout.strip() == ""
-    assert result.stderr.strip() == "ruff: command not found"