validate-family.py, validate-pins.py and both bootstrap.py copies: a git Windows cannot execute ([WinError 193], a nameless OSError) is git-not-runnable, exit 2, with the put-git-on-PATH remedy, where each ended in a traceback, exit 1, and one test holds the four copies to one answer and one text (#1001)

templates/assembly-root/scripts/bootstrap.py

@@ -328,15 +328,18 @@ def _git_runs(unread: str) -> Iterator[None]:
     words are the validators'. Which `OSError` is git's is read as
     `validate-pins.py` reads it, by NAME: one whose `filename` is `git`, or
     a nameless `FileNotFoundError` or `PermissionError`, which is what
-    Windows raises for a program it cannot start. An error that names a
-    directory, which `subprocess` raises for a `cwd` it cannot enter, is
-    not git's, and goes on as it did.
+    Windows raises for a program it cannot start, or a nameless `OSError`
+    whose `winerror` is 193, which it raises for a `git.exe` it cannot
+    execute (#1001). An error that names a directory, which `subprocess`
+    raises for a `cwd` it cannot enter, is not git's, and goes on as it did.
     """
     try:
         yield
     except OSError as exc:
-        if exc.filename != "git" and (exc.filename is not None or not (
-                isinstance(exc, (FileNotFoundError, PermissionError)))):
+        nameless = (exc.filename is None
+                    and (isinstance(exc, (FileNotFoundError, PermissionError))
+                         or getattr(exc, "winerror", None) == 193))
+        if exc.filename != "git" and not nameless:
             raise
         raise Refusal("git-not-runnable",
                       f"{unread}: git could not be run "

templates/assembly-root/scripts/validate-pins.py

@@ -799,11 +799,12 @@ def _git_runs(unread: str) -> Iterator[None]:
     `filename` where a program that will not start names `git`. So the rule
     is the NAME: any `OSError` whose `filename` is `git` counts, `ENOEXEC`'s
     included, and an error that names a directory or any other file passes
-    through unchanged, and so does any `OSError` that names none. The one
-    nameless error that counts is a `FileNotFoundError` or a
-    `PermissionError`: Windows' `CreateProcess` failures carry no filename,
-    so a missing git there is `[WinError 2]` with `filename` None, and
-    nothing says it was the directory.
+    through unchanged. Of the errors that name none, only a
+    `FileNotFoundError` or a `PermissionError` counts, and an `OSError`
+    whose `winerror` is 193: Windows' `CreateProcess` failures carry no
+    filename, so a missing git there is `[WinError 2]` with `filename` None,
+    and nothing says it was the directory, and a `git.exe` it cannot
+    execute is `[WinError 193]`, which is neither class (#1001).
 
     `recorded_gitlink`'s `except Refusal` is not in the way: an `OSError` is
     no `Refusal`, so a missing git reaches here instead of reading as "no
@@ -813,7 +814,8 @@ def _git_runs(unread: str) -> Iterator[None]:
         yield
     except OSError as exc:
         nameless = (exc.filename is None
-                    and isinstance(exc, (FileNotFoundError, PermissionError)))
+                    and (isinstance(exc, (FileNotFoundError, PermissionError))
+                         or getattr(exc, "winerror", None) == 193))
         if exc.filename != "git" and not nameless:
             raise
         raise Refusal(

templates/family-root/scripts/bootstrap.py

@@ -462,11 +462,14 @@ def git_not_started(exc: OSError) -> Refusal | None:
     `FileNotFoundError` traceback, exit 1, the code of `family bootstrap
     FAILED`, though nothing had failed. Git's is told by its NAME, as
     `validate-pins.py` tells it: a `filename` of `git`, or none at all on a
-    `FileNotFoundError` or a `PermissionError`, as Windows raises them; one
-    naming a directory is not git's. The code, and the remedy's first
-    sentence, are `validate-family.py`'s."""
-    nameless = exc.filename is None and isinstance(
-        exc, (FileNotFoundError, PermissionError))
+    `FileNotFoundError` or a `PermissionError`, as Windows raises them, or
+    on an `OSError` whose `winerror` is 193, Windows' `[WinError 193]` for a
+    `git.exe` it cannot execute (#1001); one naming a directory is not
+    git's. The code, and the remedy's first sentence, are
+    `validate-family.py`'s."""
+    nameless = (exc.filename is None
+                and (isinstance(exc, (FileNotFoundError, PermissionError))
+                     or getattr(exc, "winerror", None) == 193))
     if exc.filename != "git" and not nameless:
         return None
     return Refusal(

templates/family-root/scripts/validate-family.py

@@ -334,23 +334,24 @@ def _git_runs(unread: str) -> Iterator[None]:
     `filename` is `git` counts, `ENOEXEC`'s included (a binary for another
     architecture, a script with no shebang), and so does a
     `FileNotFoundError` or a `PermissionError` that names no file, as
-    Windows' `CreateProcess` raises one for a missing git. Every other
-    `OSError` passes through as it came, and so does Windows' `[WinError
-    193]`, a `git.exe` it cannot execute, which names no file and is
-    neither class: `validate-pins.py` passes it through as well.
+    Windows' `CreateProcess` raises one for a missing git, and so does an
+    `OSError` that names none whose `winerror` is 193, Windows' `[WinError
+    193]` for a `git.exe` it cannot execute, which is neither class (#1001).
+    Every other `OSError` passes through as it came.
 
     `validate-pins.py`'s RULE, COPIED, NOT SHARED. This file is a pinned
     copy, and a holder re-copies its pinned files one row at a time, so it
     may run beside a `repo_shape.py` older than itself: a rule moved there
     would end this run in an `ImportError` (#610's skew rule).
-    `tests/test_validate_family_git_not_runnable.py` holds the two copies to
-    one answer.
+    `tests/test_validate_family_git_not_runnable.py` holds this copy, that
+    one and both `bootstrap.py`s' to one answer and one text.
     """
     try:
         yield
     except OSError as exc:
         nameless = (exc.filename is None
-                    and isinstance(exc, (FileNotFoundError, PermissionError)))
+                    and (isinstance(exc, (FileNotFoundError, PermissionError))
+                         or getattr(exc, "winerror", None) == 193))
         if exc.filename != "git" and not nameless:
             raise
         raise Refusal(

tests/test_bootstrap_without_git.py

@@ -19,7 +19,9 @@
 going on would only say it again. Which `OSError` is git's is read by NAME,
 as `validate-pins.py` reads it: `filename` `git`, or none on a
 `FileNotFoundError` or a `PermissionError`, which is how Windows raises
-them; an error naming a directory goes on as it did.
+them, or on an `OSError` whose `winerror` is 193, Windows' `[WinError 193]`
+for a `git.exe` it cannot execute (#1001); an error naming a directory goes
+on as it did.
 
 The end-to-end runs are a person's: a scaffold's recursive clone, a plain
 clone, and a family holder, each run with no git on `PATH`. The rule's other
@@ -37,6 +39,7 @@
 from conftest import (PROJECT, REPO, clone_just_pushed, load_without_bytecode,
                       run_script)
 from test_family import family, holder  # noqa: F401
+from test_validate_pins_without_git import WIN_ERROR_193
 
 #: What `subprocess` says when there is no git to start, here.
 NO_GIT = ("The system cannot find the file specified" if os.name == "nt"
@@ -53,6 +56,33 @@
     "through git too, so without it nothing here can be fetched or "
     "bootstrapped.")
 
+#: What stands where a `git.exe` Windows cannot execute would. Python imports
+#: `sitecustomize` at start-up from `PYTHONPATH`, so the script, and anything
+#: it starts, load this first, as `tests/test_update_shape_landing.py`'s
+#: `GH_ON_PATH` stands in for `gh`. Starting a program named `git` raises
+#: what CPython raises on Windows there, `WIN_ERROR_193`; nothing else
+#: changes.
+GIT_NOT_WIN32 = """\
+import errno
+import os
+import subprocess
+
+
+class _Popen(subprocess.Popen):
+    def __init__(self, args, *rest, **kwargs):
+        if (isinstance(args, (list, tuple)) and args
+                and os.path.basename(str(args[0])).lower()
+                in ("git", "git.exe")):
+            error = OSError(errno.ENOEXEC,
+                            "%1 is not a valid Win32 application")
+            error.winerror = 193
+            raise error
+        super().__init__(args, *rest, **kwargs)
+
+
+subprocess.Popen = _Popen
+"""
+
 
 def without_git(root: Path, tmp_path: Path, *extra: str,
                 env: dict | None = None):
@@ -89,25 +119,37 @@ def test_an_assembly_root_with_no_git_refuses_in_step_a(project, tmp_path,
         "\n(a) legs on tracking branches, pins untouched\n"), result.stdout
 
 
+@pytest.mark.parametrize("shim, said", [
+    (None, NO_GIT), (GIT_NOT_WIN32, WIN_ERROR_193.strerror)],
+    ids=["no-git", "winerror-193"])
 def test_the_offline_upstream_notice_with_no_git_refuses_too(scaffolded,
-                                                             tmp_path):
+                                                             tmp_path, shim,
+                                                             said):
     """A PLAIN clone: both legs NOT INITIALIZED, so step (a) runs no git, and
     `SHAPE_UPSTREAM_PATH` names a directory, so the notice after the
     validators runs one. `validate-pins.py` refuses `git-not-runnable`
     itself; the notice then ended the run in a traceback. It refuses, and
-    the review-authority step is not reached."""
+    the review-authority step is not reached. So it does where every start
+    of git raises Windows' `[WinError 193]` (`GIT_NOT_WIN32`; #1001,
+    RV1028's NIT 1), which the notice's `except OSError` used to swallow
+    and say nothing of."""
     clone = tmp_path / PROJECT
     made = clone_just_pushed(scaffolded["remotes"] / f"{PROJECT}.git", clone,
                              recurse=False)
     assert made.returncode == 0, made.stderr
     upstream = tmp_path / "upstream"
     upstream.mkdir()
-
-    result = without_git(clone, tmp_path,
-                         env={"SHAPE_UPSTREAM_PATH": str(upstream)})
+    env = {"SHAPE_UPSTREAM_PATH": str(upstream)}
+    if shim is not None:
+        sitecustomize = tmp_path / "git-not-win32"
+        sitecustomize.mkdir()
+        (sitecustomize / "sitecustomize.py").write_text(shim, encoding="utf-8")
+        env["PYTHONPATH"] = str(sitecustomize)
+
+    result = without_git(clone, tmp_path, env=env)
     refused(result,
             "REFUSED git-not-runnable: the clone SHAPE_UPSTREAM_PATH names, "
-            f"{upstream}, could not be read: git could not be run ({NO_GIT})",
+            f"{upstream}, could not be read: git could not be run ({said})",
             ASSEMBLY_REMEDY)
     assert "  [spec] spec: NOT INITIALIZED." in result.stdout, result.stdout
     assert "(c) review authority" not in result.stdout
@@ -157,12 +199,16 @@ def made_of(module, error: OSError):
     PermissionError(errno.EACCES, "Permission denied", "git"),
     OSError(errno.ENOEXEC, "Exec format error", "git"),
     FileNotFoundError(2, "The system cannot find the file specified"),
-], ids=["no git", "git not executable", "git no program", "windows"])
+    WIN_ERROR_193,
+], ids=["no git", "git not executable", "git no program", "windows",
+        "windows winerror 193"])
 def test_each_way_git_cannot_start_is_git_not_runnable(root_module, error):
     made = made_of(root_module, error)
     assert made.code == "git-not-runnable", made
     assert made.detail.endswith(
         f": git could not be run ({error.strerror})"), made.detail
+    assert made.remediation.startswith(
+        "Remediation: put git on PATH and run this again. "), made
 
 
 @pytest.mark.parametrize("error", [